Hubbry Logo
Time-sharingTime-sharingMain
Open search
Time-sharing
Community hub
Time-sharing
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Time-sharing
Time-sharing
Time-sharing
View on Wikipedia
from Wikipedia
History of computing
Hardware
Software
Computer science
Modern concepts
By country
Timeline of computing
Glossary of computer science

In computing, time-sharing is the concurrent sharing of a computing resource among many tasks or users by giving each task or user a small slice of processing time. This quick switch between tasks or users gives the illusion of simultaneous execution.[1][2] It enables multi-tasking by a single user or enables multiple-user sessions.

Developed during the 1960s, its emergence as the prominent model of computing in the 1970s represented a major technological shift in the history of computing. By allowing many users to interact concurrently with a single computer, time-sharing dramatically lowered the cost of providing computing capability, made it possible for individuals and organizations to use a computer without owning one,[3] and promoted the interactive use of computers and the development of new interactive applications.

History

[edit]

Batch processing

[edit]
Main article: Batch processing

The earliest computers were extremely expensive devices, and very slow. Machines were typically dedicated to a particular set of tasks and operated by control panels, the operator manually entering small programs via switches one at a time. These programs might take hours to run. As computers increased in speed, run times dropped, and soon the time taken to start up the next program became a concern. Newer batch processing software and methodologies, including batch operating systems such as IBSYS (1960), decreased these "dead periods" by queuing up programs ready to run.[4]

Comparatively inexpensive card punch or paper tape writers were used by programmers to write their programs "offline". Programs were submitted to the operations team, which scheduled them to be run. Output (generally printed) was returned to the programmer. The complete process might take days, during which time the programmer might never see the computer. Stanford students made a short film humorously critiquing this situation.[5]

The alternative of allowing the user to operate the computer directly was generally far too expensive to consider. This was because users might have long periods of entering code while the computer remained idle. This situation limited interactive development to those organizations that could afford to waste computing cycles: large universities for the most part.

Time-sharing

[edit]
Unix time-sharing at the University of Wisconsin, 1978

The term time-sharing has had two major uses, one prior to 1960 and the other after. In the earliest uses, the term (used without the hyphen) referred to what we now call multiprogramming.[6] Robert Dodds claimed to have been first to describe this form of time sharing in a letter he wrote to Bob Bemer in 1949. Later John Backus described the concept in the 1954 summer session at MIT.[7] In a 1957 article "How to consider a computer" in Automatic Control Magazine , Bob Bemer outlined the economic reasons for using one large computer shared among multiple users, whose programs are “interleaved.” He also proposed a computer utility that would provide computing power to multiple users, similarly to how electricity is provided by power companies.[6][8][9] In a paper published in December 1958, W. F. Bauer described how a "parallel system" like LARC or Gamma 60 allowed "large components of the machine [to] be time-shared" and also proposed that large regional computers provide computing power to organizations in their region.[10]

Christopher Strachey, who became Oxford University's first professor of computation, filed a patent application in the United Kingdom for "time-sharing" in February 1959.[11][12] In June of that year, he gave a paper "Time Sharing in Large Fast Computers"[13] at the first UNESCO Information Processing Conference in Paris, in which he described solutions to various technical problems raised by the idea of time-sharing. At the same conference, he passed the concept on to J. C. R. Licklider of Bolt Beranek and Newman (BBN).[14] This paper was credited by the MIT Computation Center in 1963 as "the first paper on time-shared computers".[15]

After 1960, the meaning of the term time-sharing shifted from its original usage and it came to mean sharing a computer interactively among multiple users.[6] In 1984 Christopher Strachey wrote he considered the change in the meaning of the term time-sharing a source of confusion and not what he meant when he wrote his paper in 1959.[6]

The first interactive, general-purpose time-sharing system usable for software development, Compatible Time-Sharing System, was initiated by John McCarthy at MIT writing a memo in 1959.[16] Fernando J. Corbató led the development of the system, a prototype of which had been produced and tested by November 1961.[17] Philip M. Morse arranged for IBM to provide a series of their mainframe computers starting with the IBM 704 and then the IBM 709 product line IBM 7090 and IBM 7094.[17] IBM loaned those mainframes at no cost to MIT along with the staff to operate them and also provided hardware modifications mostly in the form of RPQs as prior customers had already commissioned the modifications.[18][17] There were certain stipulations that governed MIT's use of the loaned IBM hardware. MIT could not charge for use of CTSS.[19] MIT could only use the IBM computers for eight hours a day; another eight hours were available for other colleges and universities; IBM could use their computers for the remaining eight hours, although there were some exceptions. In 1963 a second deployment of CTSS was installed on an IBM 7094 that MIT has purchased using ARPA money. This was used to support Multics development at Project MAC.[17]

During the same period, Licklider led the development of the BBN Time-Sharing System, which began operation and was publicly demonstrated in 1962.

JOSS began time-sharing service in January 1964.[20] Dartmouth Time-Sharing System (DTSS) began service in March 1964.[21]

Development

[edit]

Throughout the late 1960s and the 1970s, computer terminals were multiplexed onto large institutional mainframe computers (centralized computing systems), which in many implementations sequentially polled the terminals to see whether any additional data was available or action was requested by the computer user. Later technology in interconnections were interrupt driven, and some of these used parallel data transfer technologies such as the IEEE 488 standard. Generally, computer terminals were utilized on college properties in much the same places as desktop computers or personal computers are found today. In the earliest days of personal computers, many were in fact used as particularly smart terminals for time-sharing systems.

DTSS's creators wrote in 1968 that "any response time which averages more than 10 seconds destroys the illusion of having one's own computer".[22] Conversely, timesharing users thought that their terminal was the computer,[23] and unless they received a bill for using the service, rarely thought about how others shared the computer's resources, such as when a large JOSS application caused paging for all users. The JOSS Newsletter often asked users to reduce storage usage.[24] Time-sharing was nonetheless an efficient way to share a large computer. As of 1972 DTSS supported more than 100 simultaneous users. Although more than 1,000 of the 19,503 jobs the system completed on "a particularly busy day" required ten seconds or more of computer time, DTSS was able to handle the jobs because 78% of jobs needed one second or less of computer time. About 75% of 3,197 users used their terminal for 30 minutes or less, during which they used less than four seconds of computer time. A football simulation, among early mainframe games written for DTSS, used less than two seconds of computer time during the 15 minutes of real time for playing the game.[25] With the rise of microcomputing in the early 1980s, time-sharing became less significant, because individual microprocessors were sufficiently inexpensive that a single person could have all the CPU time dedicated solely to their needs, even when idle.

However, the Internet brought the general concept of time-sharing back into popularity. Expensive corporate server farms costing millions can host thousands of customers all sharing the same common resources. As with the early serial terminals, web sites operate primarily in bursts of activity followed by periods of idle time. This bursting nature permits the service to be used by many customers at once, usually with no perceptible communication delays, unless the servers start to get very busy.

Time-sharing business

[edit]

Genesis

[edit]

In the 1960s, several companies started providing time-sharing services as service bureaus. Early systems used Teletype Model 33 KSR or ASR or Teletype Model 35 KSR or ASR machines in ASCII environments, and IBM Selectric typewriter-based terminals (especially the IBM 2741) with two different seven-bit codes.[26] They would connect to the central computer by dial-up Bell 103A modem or acoustically coupled modems operating at 10–15 characters per second. Later terminals and modems supported 30–120 characters per second. The time-sharing system would provide a complete operating environment, including a variety of programming language processors, various software packages, file storage, bulk printing, and off-line storage. Users were charged rent for the terminal, a charge for hours of connect time, a charge for seconds of CPU time, and a charge for kilobyte-months of disk storage.

Common systems used for time-sharing included the SDS 940, the PDP-10, the IBM 360, and the GE-600 series. Companies providing this service included GE's GEISCO, the IBM subsidiary The Service Bureau Corporation, Tymshare (founded in 1966), National CSS (founded in 1967 and bought by Dun & Bradstreet in 1979), Dial Data (bought by Tymshare in 1968), AL/COM, Bolt, Beranek, and Newman (BBN) and Time Sharing Ltd. in the UK.[27] By 1968, there were 32 such service bureaus serving the US National Institutes of Health (NIH) alone.[28] The Auerbach Guide to Timesharing (1973) lists 125 different timesharing services using equipment from Burroughs, CDC, DEC, HP, Honeywell, IBM, RCA, Univac, and XDS.[29][30]

Rise and fall

[edit]

In 1975, acting president of Prime Computer Ben F. Robelen told stockholders that "The biggest end-user market currently is time-sharing".[31] For DEC, for a while the second largest computer company (after IBM), this was also true: Their PDP-10 and IBM's 360/67[32] were widely used[33] by commercial timesharing services such as CompuServe, On-Line Systems, Inc. (OLS), Rapidata and Time Sharing Ltd.

The advent of the personal computer marked the beginning of the decline of time-sharing.[citation needed] The economics were such that computer time went from being an expensive resource that had to be shared to being so cheap that computers could be left to sit idle for long periods in order to be available as needed.[citation needed]

Rapidata as an example
[edit]

Although many time-sharing services simply closed, Rapidata[34][35] held on, and became part of National Data Corporation.[36] It was still of sufficient interest in 1982 to be the focus of "A User's Guide to Statistics Programs: The Rapidata Timesharing System".[37] Even as revenue fell by 66%[38] and National Data subsequently developed its own problems, attempts were made to keep this timesharing business going.[39][40][41]

Time-sharing in the United Kingdom

[edit]
  • Time Sharing Limited (TSL, 1969–1974) - launched using DEC systems. PERT was one of its popular offerings. TSL was acquired by ADP in 1974.
  • OLS Computer Services (UK) Limited (1975–1980) - using HP & DEC systems.

The computer utility

[edit]

Beginning in 1964, the Multics operating system[42] was designed as a computing utility, modeled on the electrical or telephone utilities. In the 1970s, Ted Nelson's original "Xanadu" hypertext repository was envisioned as such a service.

Security

[edit]

Time-sharing was the first time that multiple processes, owned by different users, were running on a single machine, and these processes could interfere with one another.[43] For example, one process might alter shared resources which another process relied on, such as a variable stored in memory. When only one user was using the system, this would result in possibly wrong output - but with multiple users, this might mean that other users got to see information they were not meant to see.

To prevent this from happening, an operating system needed to enforce a set of policies that determined which privileges each process had. For example, the operating system might deny access to a certain variable by a certain process.

The first international conference on computer security in London in 1971 was primarily driven by the time-sharing industry and its customers.[44]

Time-sharing in the form of shell accounts has been considered a risk.[45]

Notable time-sharing systems

[edit]
See also: Time-sharing system evolution

Significant early timesharing systems:[29]

See also

[edit]

References

[edit]

Further reading

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Time-sharing

View on Grokipedia
from Grokipedia
Time-sharing is a technique that allows multiple users to interact nearly simultaneously with a single computer system by allocating short, rapid slices of (CPU) time to each user or process, thereby creating the illusion of exclusive access for each participant while optimizing resource utilization. This method contrasts with earlier approaches, where jobs were executed sequentially without user interaction, and it enables efficient sharing of expensive mainframe hardware among numerous terminals. The concept of time-sharing emerged in the mid-1950s amid growing demand for more accessible computing resources, with early ideas proposed by figures such as at MIT in 1955 and John McCarthy, who envisioned users behaving as if in sole control of a machine. McCarthy's 1957 proposal for the involved minimal hardware modifications, like interrupts and , to support multiple Flexowriter terminals, though initial implementations were delayed by funding and technical challenges. By the early 1960s, practical systems materialized, including the (CTSS) developed at MIT's Computation Center under Fernando Corbató, which ran on a modified in 1961 and supported up to 30 users by 1963. Key developments accelerated through federally funded projects, notably MIT's Project MAC (1963–1968), directed by Robert M. Fano and supported by ARPA's Information Processing Techniques Office under , which received $3 million annually to pioneer multiple-access computing and influenced over a dozen similar initiatives by 1967. This era also saw innovations like Bolt, Beranek and Newman's (BBN) time-sharing on the in 1962 and McCarthy's system at Stanford, which operated until around 1970. IBM contributed significantly with the System/360 series in 1964, particularly Models 64 and 66, designed for concurrent multi-user operations, while systems like (evolving from CTSS) laid groundwork for modern operating systems such as UNIX. Time-sharing's advantages include enhanced , reduced wait times for users, and broader to computing power, transforming mainframes from batch-oriented tools into dynamic, multi-user environments that spurred the growth of computer utilities and service bureaus. By the late , it had become a foundational in operating system design, enabling concurrent program execution and influencing subsequent technologies like virtual machines and precursors.

Core Concepts

Definition and Principles

Time-sharing is a that enables multiple users to interactively access and utilize a single simultaneously, achieving this through the rapid allocation and deallocation of the (CPU) among various user . This technique creates the appearance that each user has exclusive control over a dedicated , despite sharing the underlying hardware resources. The core mechanism involves dividing the CPU's processing time into small intervals, known as time slices, during which a particular executes before the system switches to another, ensuring equitable distribution of computational power. At its foundation, time-sharing operates on principles of time-slicing, context switching, and resource sharing to foster interactivity and responsiveness. Time-slicing allocates brief, fixed-duration periods of to each , typically on the order of milliseconds, allowing the operating system to and resume execution seamlessly. Context switching preserves the state of the current —such as register values and mappings—before loading the state of the next , minimizing disruption and enabling smooth transitions. Virtual terminals further support this by providing each user with an independent interface for input and output, simulating a personal environment while the operating system orchestrates concurrent access to shared resources like and peripherals. The operating system plays a pivotal in managing user sessions, which encapsulate each individual's ongoing interactions, including commands, programs, and . It handles concurrent access by maintaining queues, prioritizing interactive tasks to ensure low-latency responses, and coordinating operations across multiple terminals. This setup emphasizes resource sharing, where idle times in one user's —such as waiting for I/O—can be exploited by others, thereby optimizing overall system efficiency. Compared to earlier non-interactive approaches like , time-sharing significantly enhances CPU utilization by keeping the processor occupied through overlapping computation and I/O activities across users, while drastically reducing wait times from job submission to execution results.

Comparison to Batch Processing and Multiprogramming

Batch processing, prevalent in early computing systems, involved the sequential execution of jobs submitted in groups or "batches" without direct user interaction during processing. Jobs were organized into queues managed by operators, who intervened to load programs, allocate resources, and handle operations, often on magnetic tapes or cards. This approach minimized setup overhead but resulted in significant drawbacks, including prolonged turnaround times—sometimes hours or days—between job submission and output receipt, as well as inefficient resource utilization, with CPUs idling during I/O waits or operator interventions. Multiprogramming emerged as an advancement over pure by loading multiple programs simultaneously into main , allowing the CPU to switch between them during I/O operations to overlap execution and maximize throughput. Unlike batch systems, multiprogramming focused on system-level efficiency, keeping the CPU busy by dispatching ready processes while others awaited peripherals, but it remained non-interactive: users submitted complete jobs via batch queues and received results offline, prioritizing overall system productivity over individual responsiveness. This paradigm improved resource utilization compared to single-program batching but still suffered from long delays and lack of real-time feedback, as execution was not tied to user sessions. Time-sharing innovated upon these foundations by introducing rapid interleaving of user tasks via time-slicing, creating the illusion of dedicated for multiple simultaneous users, each interacting through remote terminals. A core distinction lies in its emphasis on quick response times—typically under one second for simple commands—to sustain user thought flow and enable conversational , contrasting sharply with the batch and multiprogramming focus on throughput and delayed outputs. While multiprogramming handled system-level task overlapping, time-sharing extended this to user-level multitasking, supporting direct command entry and immediate feedback from dispersed terminals, thus transforming from a queued service to an interactive utility. This evolution was bridged by multiprogramming's technical contributions, particularly in and process management, which prevented interference among concurrent programs and enabled safe resource sharing essential for scaling to interactive multi-user environments. Without such mechanisms, time-sharing's concurrent execution of diverse user tasks would risk system instability or .

Historical Development

Precursors and Early Ideas

The intellectual foundations of time-sharing emerged in the mid-1950s amid growing interest in making more interactive and efficient, moving beyond the limitations of single-user operation. As early as 1955, the concept was first described by IBM's at a summer session at MIT, suggesting that a large computer could function as multiple small ones through time-sharing. Independently, John McCarthy at MIT began conceptualizing systems where multiple users could access a computer as if each had sole control, proposing mechanisms like interrupts to facilitate this sharing. This idea was formalized in McCarthy's 1959 internal memo to Philip Morse, which outlined online debugging and support for numerous remote terminals connected to a central machine, though it underestimated the processing power required. Independently, in 1959, British mathematician presented one of the first public proposals for time-sharing in his paper "Time Sharing in Large Fast Computers" at the IFIP Congress in , advocating for rapid switching between user programs to enable conversational interaction with high-speed machines. These theoretical ideas drew inspiration from developments in military applications during the , which emphasized rapid response times essential for interactive systems. The project at MIT, initiated in 1944 and operational by 1951, pioneered real-time digital computation for applications like flight simulation, introducing core memory and display technologies that supported immediate user feedback and laid groundwork for handling multiple inputs dynamically. Similarly, the SAGE () air defense system, developed from 1951 onward by MIT's Lincoln Laboratory and , incorporated early forms of program time-slicing and multiprogramming to process radar data in real time across networked sites, demonstrating the feasibility of allocation under strict timing constraints. These systems highlighted the potential for computers to manage concurrent tasks, influencing visions of broader user access. However, widespread adoption of such interactive concepts was hindered by the era's technological constraints. Computers in the , such as the , were extraordinarily expensive—often costing millions of dollars—and required dedicated environments with high power consumption, limiting them to large institutions. operations were notoriously slow, relying on punched cards, magnetic tapes, or teleprinters that took seconds or minutes per transaction, making rapid context-switching impractical without advanced buffering. Moreover, software ecosystems lacked robust supervisory programs or interrupt handlers, forcing reliance on manual intervention and exacerbating inefficiencies in resource management. Amid these challenges, computing literature began envisioning a paradigm shift from centralized —where jobs were submitted sequentially via offline media and processed without user interaction—to a model of computers as public utilities akin to or . Proposals in scientific and reports, such as those analyzing late-1950s installations, advocated for remote terminals and supervisory software to enable "hands-off" user control, promoting shared access to boost productivity across distributed users. This utility metaphor underscored the potential for computing to become a democratized service, though hardware and communication unreliability delayed realization.

Invention and Key Milestones

The invention of time-sharing is credited to the development of the (CTSS) at the Massachusetts Institute of Technology (MIT) in 1961, led by and his team at the MIT Computation Center. CTSS was first demonstrated in November 1961 on a modified mainframe, enabling interactive multi-user access by rapidly switching the processor among multiple users' tasks, thus providing the illusion of dedicated computing resources to each. This breakthrough addressed the limitations of by allowing concurrent user interactions via remote terminals, marking the practical realization of earlier theoretical ideas for shared computing. A pivotal milestone occurred in 1963 with the establishment of Project MAC at MIT, funded by the Advanced Research Projects Agency (), which expanded CTSS capabilities and explored broader applications of time-sharing in computing . Project MAC's ARPA support, starting with a signed on , 1963, accelerated the adoption of time-sharing by providing resources for hardware modifications and software innovations, influencing subsequent systems nationwide. In 1964, development of (Multiplexed Information and Computing Service) began as a collaborative effort among MIT's Project MAC, Bell Telephone Laboratories, and , aiming to create a more scalable, secure time-sharing operating system for the GE-645 computer. The project's first public presentation came in December 1965 at the Fall Joint Computer Conference, where six papers outlined Multics' design for hierarchical file systems and dynamic resource allocation. The 1960s also saw commercial interest in time-sharing, exemplified by IBM's introduction of the Time-Sharing System (TSS/360) in 1967 for the System/360 Model 67 mainframe, which incorporated time-slicing to support up to 32 simultaneous users through rapid context switching. This system represented an early industry attempt to bring interactive multi-user to enterprise environments, building on academic prototypes like CTSS. In the 1970s, time-sharing advanced through the development of UNIX at Bell Laboratories, starting in 1969 by and Dennis M. Ritchie as a simplified, portable operating system that incorporated time-sharing elements for multi-user interaction on s. UNIX's first operational version on the PDP-11 in 1971 enabled efficient time-slicing and management, fostering widespread adoption in and . The spread to s like the PDP-11 series, introduced by in 1970, democratized time-sharing by making interactive systems affordable for smaller institutions, with operating systems such as UNIX and RSTS supporting dozens of concurrent users.

Commercial Expansion

The commercialization of time-sharing accelerated in the mid-1960s as major hardware vendors adapted their systems for interactive, multi-user environments to meet growing demands for efficient access. In , introduced the System/360 Model 67, an extension of its S/360 architecture specifically designed to support time-sharing through features like via a Dynamic Address Translation unit, enabling multiple users to interact concurrently with the system. Similarly, (DEC) launched the in 1966, paired with the TOPS-10 operating system, which facilitated time-sharing on this 36-bit mainframe by supporting multiprogramming and terminal-based interactions, becoming a staple for commercial and research installations. These systems marked the transition from experimental prototypes to viable commercial products, influenced briefly by designs like , which demonstrated scalable multi-user security and resource sharing. Service providers emerged rapidly in the late , offering remote access to time-sharing resources as an alternative to in-house ownership of costly mainframes. launched its GE-265 time-sharing service in 1965, utilizing a combination of GE-235 processors and Datanet-30 communications controllers to deliver interactive computing to customers across multiple states, starting with installations in . Tymshare, founded in 1964, expanded its offerings in 1969 with Tymnet, a packet-switched network built on Varian Data 620 minicomputers that connected users to SDS-940-based time-sharing systems, enabling nationwide remote access for businesses and researchers. National CSS followed suit in the late , providing the VP/CSS operating system on hardware, which supported and multi-user terminals for commercial clients seeking affordable computational power. Market drivers for this expansion included surging demand from universities and businesses for remote, on-demand without the prohibitive costs of dedicated machines, alongside technological advances that lowered . Academic institutions required interactive access for and , while enterprises in and valued the productivity gains from shared resources over . The advent of minicomputers in the , such as those from DEC and SDS, reduced hardware expenses dramatically—often to a of mainframe costs—fueling the proliferation of time-sharing services and installations. By the , the sector peaked with hundreds of such systems deployed, as evidenced by over 250 computers in use by time-sharing firms by and continued growth into the decade. Key events underscored this commercial momentum, including the 1972 surge in dedicated time-sharing bureaus, with firms like Tymshare operating 23 SDS-940 systems to serve expanding client bases. Integration with emerging networks like further propelled adoption, as protocols such as enabled seamless remote access to time-sharing hosts across connected institutions starting in the early , optimizing resource utilization in distributed environments.

Technical Mechanisms

Scheduling and Resource Allocation

In time-sharing systems, CPU scheduling primarily relies on round-robin time-slicing, where the processor allocates fixed quanta of , typically 100-200 milliseconds, to each active in a cyclic manner. This mechanism ensures that multiple users experience near-simultaneous access, with a interrupt signaling the end of each quantum to the current process and switch to the next. The approach promotes responsiveness by limiting any single process's uninterrupted execution, thereby preventing monopolization of the CPU while maintaining high utilization rates. To accommodate diverse workloads, including interactive user tasks and longer-running batch jobs, time-sharing systems often incorporate priority-based scheduling. Processes are assigned priorities based on factors such as job type or estimated runtime, with higher-priority tasks receiving preferential quanta allocation or shorter wait times. This multilevel strategy balances the needs of time-sensitive interactive sessions against compute-intensive operations, using queues to manage processes at different priority levels. Resource allocation in time-sharing extends to memory management through partitioning and swapping techniques. Memory is divided into fixed or variable partitions to accommodate multiple processes simultaneously, with inactive ones swapped to secondary storage to free core memory for active tasks. Early systems like CTSS initially used for swapping before transitioning to drums and disks. These implementations served as precursors to , employing segmentation to provide processes with the illusion of dedicated address spaces larger than physical memory, combined with paging for efficient mapping and protection. Swapping minimizes contention by overlapping I/O operations with , ensuring resources are dynamically reassigned without halting system operation. Scheduling policies emphasize fair sharing to avoid , where low-priority processes might otherwise indefinitely defer higher ones; techniques like aging periodically increment priorities of waiting processes to guarantee eventual execution. Interrupt handling further enhances responsiveness, as external events (e.g., I/O completion) trigger immediate rescheduling to prioritize urgent tasks over ongoing quanta. CPU efficiency in round-robin can be estimated as the ratio of useful computation time to total elapsed time, excluding idle periods. overhead, involving state saving and restoration, influences quantum selection to optimize overall throughput.

Input/Output Handling

In time-sharing systems, input/output (I/O) operations are multiplexed across multiple users to ensure efficient resource utilization without dedicating hardware exclusively to any single terminal. This is achieved primarily through interrupt-driven mechanisms, where terminal inputs trigger hardware interrupts that alert the operating system to handle incoming data asynchronously, preventing the CPU from blocking while waiting for slow peripheral responses. For higher-speed devices such as disks, (DMA) allows peripherals to transfer data directly to or from memory, bypassing the CPU to maintain responsiveness for all users. These techniques integrate briefly with CPU scheduling to coordinate overall system flow, ensuring that I/O-bound processes do not monopolize processing quanta. Buffering plays a critical role in managing the disparity between CPU speeds and peripheral rates, with line buffering commonly employed for keyboard inputs to collect complete lines before processing, thus reducing frequency and overhead. In systems like CTSS, supervisor-managed buffers of a few lines are used for I/O, placing user programs in an I/O wait state when buffers approach full or empty, allowing the scheduler to switch to other users during these periods. For output, print queues jobs to for deferred processing on shared printers, enabling multiple users to submit print requests without immediate contention for the device; this involves temporary storage of output files and batch execution by a dedicated spooling daemon. Terminal management in time-sharing environments supports asynchronous communication over modems, where data is transmitted serially at rates matching remote devices, often using protocols like ASCII over lines to connect distant users. Early systems accommodated various terminal types, such as or Flexowriter, with software handling (e.g., 6-bit or 12-bit modes) and input completion signals like carriage returns. As cathode-ray tube (CRT) terminals emerged, support for escape sequences enabled cursor control and screen formatting, allowing more interactive editing without full-line redraws. These mechanisms address key challenges like latency from slow teletypes, which operate at approximately 10 characters per second, potentially causing perceptible delays in interactive sessions. To mitigate this, techniques such as double buffering are employed, where one buffer is filled or emptied while the other is actively used, overlapping I/O with to sustain user responsiveness even during transmission pauses. In CTSS, for instance, double buffering with 470-word blocks for disk I/O further exemplifies this approach, ensuring that terminal interactions remain fluid despite hardware constraints.

Notable Implementations

Academic and Research Systems

The (CTSS), developed at MIT's Computation Center from 1961 and later under Project MAC until 1969, was the first operational time-sharing system and ran on modified and 7094 mainframes. It introduced key innovations such as virtual machines for user isolation, with the supervisor providing up to 30 concurrent virtual machines on the IBM 7094, each appearing as a dedicated computer to the user. CTSS featured an online with per-user directories and shared "common files" accessible across sessions, enabling collaborative with basic access controls implemented in its second version. Additionally, it included early command interpreters like —a macro facility for automating command sequences that served as a precursor to Unix shells—and tools such as TYSET and RUNOFF for text processing and formatting. The Dartmouth Time-Sharing System (DTSS), developed in 1963–1964 by John Kemeny and Thomas E. Kurtz at Dartmouth College, was an early academic time-sharing implementation designed to make computing accessible to students and faculty. It ran on a GE-225 mainframe paired with a Datanet-30 communications processor, supporting initial simultaneous access for up to 16 users via teletype terminals and later expanding to hundreds. DTSS introduced the BASIC programming language, enabling novice users to write and execute simple programs interactively, and featured a user-friendly command interface for tasks like editing and file management. Operational from 1964 until 1991, it influenced educational computing and commercial adaptations, such as General Electric's time-sharing services. Building on CTSS, (Multiplexed Information and Computing Service), initiated in 1965 by MIT, , and , became operational in 1969 and continued into the 1980s on GE-645 and later Honeywell 6180 mainframes. A of its design was the , the first of its kind, which organized files in a integrated with , allowing seamless access to storage as if it were part of main memory. pioneered mechanisms through its ring-based architecture, featuring eight concentric rings (0-7) of privilege levels, where inner rings held higher access rights and hardware enforced transitions to prevent unauthorized escalations. These rings, detailed in seminal work by Schroeder and Saltzer, provided a foundational model for segmented and influenced subsequent operating system research by enabling fine-grained control over resource access in multi-user environments. The system's emphasis on and modularity, including user and lists, established benchmarks for secure time-sharing that informed later designs. TOPS-20, developed by (DEC) in the 1970s for the family (including the KL10 processor), evolved from the TENEX system and supported robust time-sharing on 36-bit mainframes used extensively in research settings. It offered advanced management with demand paging across a 262-kword , allowing multiple user processes to run concurrently without interference. As a key component of the backbone in the 1970s, TOPS-20 facilitated early wide-area networking by integrating native support for packet-switched communications, enabling seamless connections among ARPA-funded research sites and promoting experiments. User tools were a highlight, including the COMND interface for structured command parsing with help features and noise-word tolerance, the TEXTI system for terminal-aware line editing, and the debugger for symbolic program development, which enhanced productivity in AI and systems research. By 1972, TOPS-20 and its predecessor had been adopted at seven ARPA sites, underscoring its role in advancing networked time-sharing. These academic systems laid critical groundwork for time-sharing : CTSS demonstrated scalable multi-user access with its 30-user limit under constrained hardware, proving the feasibility of interactive . ' protection rings became a of operating system , inspiring mechanisms in modern kernels for isolation and privilege management. TOPS-20's networking integrations accelerated ARPANET's growth, influencing protocols and tools that shaped internet-era environments. Their designs were later adapted in commercial offerings, but their primary legacy remains in advancing foundational OS concepts.

Commercial Time-Sharing Services

Tymshare, founded in 1966, emerged as one of the leading commercial time-sharing providers in the United States, operating until 1984. The company initially utilized Scientific Data Systems (SDS) 940 hardware to deliver remote access to computing resources, enabling multiple users to interact with the system simultaneously via dedicated terminals. By the early 1970s, Tymshare had expanded its reach through the proprietary Tymnet network, which connected users across dozens of cities using packet-switching technology to route data efficiently to host computers. This infrastructure supported a growing customer base, primarily consisting of engineers and businesses requiring on-demand computational power for and analysis tasks. General Electric Information Services (GEIS), active from the mid-1960s through the 1970s, offered one of the earliest commercial time-sharing platforms with its Mark III system. Building on adaptations of the Dartmouth Time-Sharing System, Mark III provided interactive computing capabilities tailored for environments, including applications such as inventory management, payroll processing, and financial reporting. The service operated over dial-up lines, allowing remote users to connect to GE's central processors for processing, which proved particularly valuable for enterprises seeking to optimize without in-house mainframes. Other prominent vendors included (part of Sperry Rand) and (CDC). 's UNIVAC 1108, introduced in the mid-1960s, supported time-sharing through its EXEC 8 operating system, which enabled multiprogramming and remote access for commercial users handling scientific and business workloads. Similarly, CDC offered time-sharing services on its mainframe systems, such as the series, promoting nationwide access for engineering simulations and data analysis via dedicated networks. By the mid-1970s, the commercial time-sharing sector had reached a projected market value exceeding $1 billion annually, driven by these vendors and reflecting widespread adoption among over 90 firms in . Access to these services typically involved hourly billing models charged via dial-up connections over standard lines, making affordable for small organizations and individuals without dedicated hardware. Users, often in fields like for and or for modeling and , connected using teletype terminals to run applications ranging from custom simulations to database queries, thereby democratizing access to high-end during the era.

Business and Societal Impact

Economic Models and Market Growth

Time-sharing services primarily operated on pay-per-use pricing models, charging users for terminal connect time ranging from $3 to $41 per hour and additional CPU usage fees of $0.006 to $2 per second, depending on the system and location. For heavy users, subscription tiers were available, with monthly fees from $25 to $1,500, often including allocated hours and priority access to resources. These models made computing accessible without full hardware ownership, leveraging mainframe leasing to distribute costs across multiple clients. The time-sharing market experienced rapid expansion, starting from less than $20 million in annual revenue in 1965 and growing to hundreds of millions by the mid-1970s, driven by the need for remote access to powerful mainframes amid rising demand from businesses and researchers. By 1975, the industry supported approximately 115 commercial vendors, with total revenues reaching around $500 million as services scaled through leased infrastructure and telecommunications networks. Major players included , which shifted its in the from primarily hardware sales to integrated services, including time-sharing via its System/360 series and remote bureaus to serve diverse clients like banks and retailers. played a key role in fueling startups, such as Comshare, founded in 1966 by alumni to commercialize time-sharing software for engineering applications. Societally, time-sharing enabled small businesses and organizations to access advanced computing without the prohibitive costs of purchasing mainframes, which often exceeded millions of dollars, thus democratizing use. Its global spread was facilitated by international networks, allowing remote connections across continents and supporting multinational operations by the 1970s.

Decline and Shift to Personal Computing

The introduction of affordable personal computers in the late and early 1980s marked a pivotal shift away from centralized time-sharing systems. The , released in 1977, was priced at approximately $1,298 for a basic configuration with 4 KB of RAM, making computing accessible to individuals and small businesses for a fraction of the cost of mainframes, which often exceeded $2 million for comparable systems in the . Similarly, the (PC), launched in 1981, started at $1,565 with 16 KB of RAM, further democratizing access to processing power and reducing reliance on remote time-sharing services. These developments eroded the economic justification for time-sharing, as users could now perform routine tasks locally without incurring per-hour charges or network dependencies. Technological advancements in minicomputers, local area networks (LANs), and UNIX-based workstations further diminished the need for centralized time-sharing. Minicomputers, such as those from , became viable alternatives in the 1970s, offering dedicated processing at lower costs and enabling departmental-level computing that bypassed large mainframes. The emergence of LANs in the early allowed networked personal machines to share resources locally, reducing dependence on remote central systems. UNIX workstations, popularized by companies like starting in 1982, supported multi-user environments on individual machines, effectively replicating time-sharing capabilities at the desktop level without external connectivity. These innovations promoted distributed architectures, where computing power was decentralized to end-users. By the mid-1980s, the time-sharing market had contracted sharply, with many services facing acquisition or closure. Tymshare, a leading provider, was acquired by McDonnell Douglas in 1984 for $308 million amid declining revenues and a broader industry downturn. Demand for time-sharing plummeted as personal computers captured the market; for instance, reported a nose-dive in time-sharing usage following the PC's rise, contributing to its financial struggles. The industry, which had been a major segment of computer services through the early 1980s, became largely obsolescent by 1985, supplanted by local computing solutions. The decline facilitated a transition of time-sharing principles into emerging paradigms like client-server models, which became prominent in the . Concepts of and multi-user access migrated to architectures where personal computers acted as clients querying dedicated servers over , laying groundwork for later distributed systems and cloud precursors. This evolution preserved efficiency gains from time-sharing while aligning with the affordability and autonomy of personal computing.

Challenges and Security

Technical Limitations

Time-sharing systems faced significant performance challenges due to the demands of multiplexing multiple users on limited hardware resources. One major issue was thrashing, a condition where excessive paging activity in systems overwhelmed the CPU with disk I/O operations, causing the system to spend more time swapping pages than executing user programs. This phenomenon, first systematically analyzed in multiprogrammed environments supporting time-sharing, led to drastic reductions in throughput as the degree of multiprogramming increased beyond the available memory capacity. Frequent context switches, essential for allocating CPU time slices to users, introduced additional overhead by requiring the saving and restoration of process states, including registers and mappings. In high-multiprogramming scenarios typical of time-sharing, this overhead was significant, particularly when scheduler decisions amplified switching . Resource allocation techniques, such as priority-based scheduling, were sometimes employed to mitigate this, but they often traded off fairness for reduced interruptions. Scalability was inherently constrained in early time-sharing implementations, with systems like the (CTSS) limited to approximately 30 simultaneous users due to and constraints on hardware such as the 709. Broader early designs rarely exceeded 100 users without performance degradation, as increasing concurrency amplified . I/O bottlenecks further exacerbated these limits, with slow peripherals like teleprinters operating at rates of 10-15 characters per second, creating queues for multiple users' input and output operations and stalling overall system responsiveness. Reliability posed another critical limitation, as time-sharing relied on centralized hardware architectures where a single component failure—such as a CPU or core module—could halt the entire system, disrupting all connected users. Recovery from such crashes often required full reboots, leading to prolonged and loss of unsaved work across the user base, without the fault isolation available in distributed setups. Attempts to address these issues included clustering multiple processors for parallel execution and rudimentary load balancing to distribute workloads, as seen in designs supporting up to eight CPUs. However, these mitigations remained heavily dependent on contemporaneous hardware advancements, such as faster and I/O channels, and could not fully overcome the fundamental constraints of monolithic architectures.

Security Vulnerabilities and Mitigations

Time-sharing systems, by design, enable multiple users to concurrently access shared hardware and , introducing security vulnerabilities that stem from this inherent resource sharing. One prominent risk is resource leaks, such as timing attacks or covert channels, where an attacker exploits variations in system timing or resource usage to infer sensitive information from another user's . For instance, in environments, an untrusted could modulate its memory access patterns to signal data to a colluding , bypassing isolation mechanisms. These covert channels were first formally identified in the context of multi-user systems, highlighting how time-sharing's multiplexing of CPU and memory creates unintended information flows. Unauthorized access posed another critical threat, often facilitated by weak passwords or session hijacking on shared terminals. Early implementations relied on simple password schemes without encryption or complexity requirements, making brute-force guessing feasible. A notable incident occurred in 1966 on the Compatible Time-Sharing System (CTSS), where a user exploited a system bug to print the entire password file, exposing all accounts and marking one of the first documented password breaches in a time-sharing environment. Terminal hijacking was also a concern, as dial-up connections and shared consoles allowed attackers to intercept or impersonate sessions if physical or line-level security was inadequate, exploiting the lack of per-session encryption in nascent networks. In the , these vulnerabilities manifested in real exploits, particularly on systems like , where untrusted users sharing hardware amplified risks. Government-sponsored "tiger teams" in the late and early successfully penetrated time-sharing systems by exploiting software flaws, such as inadequate argument validation and unprotected stack operations, demonstrating systemic weaknesses in multi-user isolation. The 1974 Multics security evaluation revealed multiple such vulnerabilities, including improper handling of segment descriptors that allowed across user processes. These incidents underscored the dangers of co-located untrusted users on shared hardware, where a single compromise could propagate across the system. To counter these threats, time-sharing systems pioneered mitigations centered on access controls and isolation. introduced access control lists (ACLs) on file segments, allowing fine-grained permissions for read, write, and execute operations based on user or group identities, which prevented unauthorized data access in multi-user scenarios. Complementing ACLs, employed protection rings—eight concentric levels of privilege (0 being the most trusted kernel ring, up to 7 for user applications)—to enforce hardware-enforced isolation, restricting lower-privilege code from accessing higher-privilege resources without explicit gates. Auditing tools, such as accounting daemons, were also implemented to log resource usage and security events; in , an auditor daemon monitored system calls and access attempts, enabling post-incident analysis and detection of anomalous behavior. These innovations in time-sharing security profoundly influenced subsequent operating systems, particularly UNIX, which adopted simplified user privilege models inspired by ' ACLs and rings. UNIX's user/group/other permission bits on files and processes evolved from Multics' discretionary access controls, providing a foundational mechanism for multi-user isolation that persists in modern systems. By emphasizing least privilege and auditable access, time-sharing's mitigations laid the groundwork for contemporary OS features, adapting ring-like protections into user/kernel mode separations.

Legacy and Modern Applications

Influence on Operating Systems

Time-sharing systems profoundly shaped the development of by introducing key mechanisms for multi-user and efficient CPU utilization. In the , UNIX directly adopted scheduling and multi-user support from earlier time-sharing systems like and the (CTSS). These influences enabled UNIX to support concurrent user sessions through time-sliced execution, where the operating system allocates CPU time to multiple es, ensuring responsive interaction for remote terminals. This foundation extended to broader operating system architectures, with systems like and inheriting concepts such as virtual terminals and job control from time-sharing paradigms. Virtual terminals, which simulate multiple independent console sessions on a single machine, originated in multi-user time-sharing environments to handle simultaneous logins without dedicated hardware. Job control features, allowing users to suspend, resume, and manage background processes (e.g., via signals like SIGSTOP and SIGCONT), further evolved from the need to coordinate multiple interactive jobs in shared systems. Preemptive multitasking, a core time-sharing innovation where the OS interrupts running processes to switch contexts based on timers or priorities, became a standard in these OSes, enabling fair and preventing any single task from monopolizing the CPU. Time-sharing also left lasting legacies in software tools designed for multi-user environments. Command shells like the (sh), introduced in in 1979, were crafted to interpret commands and manage pipelines in a time-shared setting, facilitating scripted automation and interactive sessions across users. Similarly, the vi editor, developed by in 1976 as a visual interface for the ex line editor, emerged in the UNIX time-sharing context at UC Berkeley, optimizing for low-bandwidth terminal access and modal editing to support efficient . Finally, time-sharing principles informed standardization efforts for portability across systems. The (Portable Operating System Interface) standards, formalized starting in the , drew heavily from UNIX time-sharing features, including process management APIs, shell utilities, and file system interfaces, to ensure software compatibility in multi-user environments. This emphasis on standardized interfaces for scheduling, signals, and has sustained the multi-user ethos in contemporary OS designs.

Contemporary Relevance

In modern , time-sharing principles manifest through multi-tenant architectures that enable multiple users or organizations to share underlying infrastructure while maintaining isolation. Platforms like (AWS) and implement this by provisioning virtual machines and resources across shared physical hardware, where compute, storage, and networking are dynamically allocated to tenants via time-sliced scheduling to optimize efficiency and cost. This approach echoes original time-sharing by allowing concurrent access without dedicated hardware, supporting scalable services for diverse workloads. Containerization technologies further extend these concepts, with tools like Docker facilitating multi-tenancy in cloud environments by encapsulating applications in lightweight, shareable containers that run on shared kernels and resources. Hypervisors such as reinforce this by employing time-slicing mechanisms to apportion CPU cycles among multiple virtual machines (VMs) on a single host, ensuring fair resource distribution and high utilization akin to early time-sharing systems. In mobile operating systems like Android, process management incorporates time-sharing via the Linux kernel's , which allocates CPU time slices to multiple processes and threads, enabling multitasking on resource-constrained smartphones while sharing memory and hardware efficiently. At the edge, multi-tenancy enables shared computing resources closer to data sources, as seen in frameworks that orchestrate containers across distributed nodes for low-latency applications. similarly revives interactive sharing by supporting multi-tenancy orchestration for real-time IoT and AI workloads. The 2020s have seen accelerated growth in Software-as-a-Service (SaaS) models, projected to expand at a (CAGR) of over 14% through 2033, driven by multi-tenant architectures that leverage time-sharing for cost-effective, scalable delivery.

References

  1. https://www.ibm.com/history/time-sharing
  2. https://www.sciencedirect.com/topics/computer-science/time-sharing-system
  3. https://historyofcomputercommunications.info/section/2.23/Timesharing-Project-MAC-1962-1968/
  4. https://www-formal.stanford.edu/jmc/history/timesharing/timesharing.html
  5. https://cseweb.ucsd.edu/classes/sp23/cse120-a/lectures/lec-2.pdf
  6. https://newport.eecs.uci.edu/~doemer/eee_uci_edu/05w/15810/Lecture1b.pdf
  7. https://courses.cs.washington.edu/courses/cse451/18wi/lectures/Lecture1_Introduction.pdf
  8. http://web.stanford.edu/~ouster/cgi-bin/cs140-winter12/lecture.php?topic=intro
  9. https://www.computerhistory.org/blog/the-whirlwind-computer-at-chm/
  10. https://www.ibm.com/history/sage
  11. https://dl.acm.org/doi/pdf/10.1145/1478873.1478980
  12. https://news.mit.edu/2019/mit-professor-emeritus-fernando-corby-corbato-computing-pioneer-dies-0715
  13. https://www.computerhistory.org/timeline/1961/
  14. https://people.csail.mit.edu/saltzer/Multics/CTSS-Documents/CTSS_50th_anniversary_web_03.pdf
  15. https://ieeexplore.ieee.org/document/145324/
  16. https://firstmonday.org/ojs/index.php/fm/article/view/611/532
  17. https://dspace.mit.edu/bitstream/handle/1721.1/149427/MIT-LCS-TR-123.pdf
  18. http://web.mit.edu/saltzer/www/publications/f7y/f7y.html
  19. http://www.bitsavers.org/pdf/ibm/360/tss/C20-1647-0_360-67_TSS_Tech.pdf
  20. https://www.read.seas.harvard.edu/~kohler/class/aosref/ritchie84evolution.pdf
  21. https://dsf.berkeley.edu/cs262/unix.pdf
  22. https://www.nokia.com/bell-labs/about/dennis-m-ritchie/retro.pdf
  23. https://dl.acm.org/doi/10.1145/1464182.1464190
  24. https://archive.computerhistory.org/resources/text/DEC/pdp-10/dec.pdp-10.the_evolution_of_the_DECsystem_10.1978.102630382.pdf
  25. https://multicians.org/multics.html
  26. https://bitsavers.org/pdf/ge/GE-2xx/GE_Time-Sharing_Activities_Jun67.pdf
  27. https://dl.acm.org/doi/pdf/10.1145/1499402.1499508
  28. https://archive.computerhistory.org/resources/access/text/2016/06/500001026-05-01-acc.pdf
  29. https://muse.jhu.edu/pub/87/article/235244/pdf
  30. https://ethw.org/Rise_and_Fall_of_Minicomputers
  31. https://www.computerhistory.org/revolution/mainframe-computers/7/181
  32. https://www.internetsociety.org/internet/history-internet/brief-history-internet/
  33. http://larch-www.lcs.mit.edu:8001/~corbato/sjcc62/
  34. https://www.andrew.cmu.edu/course/15-440/assets/READINGS/daley1968.pdf
  35. https://dtss.dartmouth.edu/history.php
  36. http://www.bitsavers.org/pdf/dartmouth/dtss/DTSS_Inc/The_Dartmouth_Time-Sharing_System_1980.pdf
  37. https://multicians.org/history.html
  38. https://multicians.org/protection.html
  39. https://www.princeton.edu/~rblee/ELE572Papers/Fall04Readings/ProtectionRings_Schroeder&Saltzer.pdf
  40. https://www.cs.utexas.edu/~witchel/380L/papers/saltzer74cacm-multics.pdf
  41. https://opost.com/tenex/hbook.html
  42. https://www.softwarehistory.org/one-of-the-two-essentials-for-computer-timesharing-to-be-viable-the-origins-of-tymnet-version-1/
  43. https://californiaconsultants.org/wp-content/uploads/2018/04/CNSV-1805-Gregory.pdf
  44. http://bitsavers.org/magazines/Datamation/197307.pdf
  45. https://bitsavers.trailing-edge.com/pdf/datapro/datapro_reports_70s-90s/_Survey_Index/70G-900-01_8111_All_About_Time-Sharing_and_Remote_Computing_Services.pdf
  46. http://archive.computerhistory.org/resources/text/GEIS/102658919.time_sharing_forbes.1970.pdf
  47. https://bitsavers.trailing-edge.com/pdf/univac/1100/datapro/70C-877-11_7009_UNIVAC_1106_1108.pdf
  48. https://www.nytimes.com/1965/11/24/archives/time-sharing-spurring-use-of-computers-group-of-customers-can-link.html
  49. https://www.fundinguniverse.com/company-histories/control-data-systems-inc-history/
  50. https://www.nytimes.com/1970/08/16/archives/keydata-timesharings-phoenix.html
  51. https://archive.computerhistory.org/resources/access/text/2017/03/102770777-05-01-acc.pdf
  52. https://d1yx3ys82bpsa0.cloudfront.net/brochures/ge.ge-400.1968.102646147.pdf
  53. http://www.nytimes.com/1965/11/24/archives/time-sharing-spurring-use-of-computers-group-of-customers-can-link.html
  54. https://www.company-histories.com/Comshare-Inc-Company-History.html
  55. https://time.com/archive/6628433/technology-sharing-the-computers-time/
  56. https://www.pcmag.com/news/45-years-ago-apple-kickstarted-the-personal-computer-industry
  57. https://www.businessinsider.com/ibm-1970-mainframe-specs-are-ridiculous-today-2014-5
  58. https://www.ibm.com/history/personal-computer
  59. https://muse.jhu.edu/pub/87/article/235244
  60. https://css.csail.mit.edu/6.824/2014/papers/plan9.pdf
  61. https://www.nytimes.com/1984/02/28/business/mcdonnell-to-buy-tymshare.html
  62. https://www.nytimes.com/1985/02/17/business/control-datas-fall-from-grace.html
  63. https://www.researchgate.net/publication/220494835_Economic_Perspectives_on_the_History_of_the_Computer_Time-Sharing_Industry_1965-1985
  64. https://web.mit.edu/15.566/spring98/notes/class12.pdf
  65. https://spectrum.ieee.org/someone-elses-computer-the-prehistory-of-cloud-computing
  66. https://dl.acm.org/doi/10.1145/1476589.1476705
  67. https://people.csail.mit.edu/saltzer/Multics/CTSS-Documents/CTSS_ProgrammersGuide_1966.pdf
  68. https://www.multicians.org/fjcc3.html
  69. https://www.thinkbrg.com/thinkset/ts-case-of-purloined-password/
  70. https://apps.dtic.mil/sti/pdfs/ADA030801.pdf
  71. https://www.acsac.org/2002/papers/classic-multics-orig.pdf
  72. https://www.cl.cam.ac.uk/teaching/1011/R01/75-protection.pdf
  73. https://seclab.cs.ucdavis.edu/projects/history/papers/karg74.pdf
  74. https://people.csail.mit.edu/saltzer/Multics/Multics-Documents/M00s/M0066.pdf
  75. https://retrocomputing.stackexchange.com/questions/15685/what-are-the-major-technical-difference-between-multics-and-unix
  76. https://pk.org/articles/big-ideas-os.html
  77. https://www.cs.cornell.edu/wya/AcademicComputing/text/earlytimesharing.html
  78. https://onlinelibrary.wiley.com/doi/abs/10.1002/j.1538-7305.1978.tb02139.x
  79. https://www.oreilly.com/library/view/learning-the-vi/1565924266/1565924266_vi6-ch-9-sect-1.html
  80. https://www.cs.unc.edu/~anderson/teach/comp790/papers/posix-rt.pdf
  81. https://www.mitre.org/sites/default/files/pdf/obenland_posix.pdf
  82. https://aws.amazon.com/solutions/guidance/multi-tenant-architectures-on-aws/
  83. https://www.redhat.com/en/topics/cloud-computing/what-is-multitenancy
  84. https://arxiv.org/html/2507.19287v1
  85. https://www.researchgate.net/publication/387867858_Multi-Tenant_Architectures_in_Modern_Cloud_Computing_A_Technical_Deep_Dive
  86. https://www.ionos.com/digitalguide/server/know-how/what-is-a-hypervisor/
  87. https://darajat.ly/wp-content/uploads/2024/06/L4-Android-OS-Processes-Scheduling-V2.pdf
  88. https://developer.android.com/guide/components/processes-and-threads
  89. https://arxiv.org/abs/2506.10461
  90. https://wraycastle.com/blogs/glossary/what-is-multi-tenant-edge-computing
  91. https://htfmarketinsights.com/report/4389652-multitenant-saas-architecture-market
Add your contribution
Related Hubs
User Avatar
No comments yet.