Community hub
0 subscribers7 pages, 0 posts
Recent from talks
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Welcome to the community hub built to collect knowledge and have discussions related to Multi-user software.
Nothing was collected or created yet.
Multi-user software
View on Wikipediafrom Wikipedia
 | This article needs additional citations for verification. (October 2022) |
Multi-user software is computer software that allows access by multiple users of a computer.[1] Time-sharing systems are multi-user systems. Most batch processing systems for mainframe computers may also be considered "multi-user", to avoid leaving the CPU idle while it waits for I/O operations to complete. However, the term "multitasking" is more common in this context.
An example is a Unix or Unix-like system where multiple remote users have access (such as via a serial port or Secure Shell) to the Unix shell prompt at the same time. Another example uses multiple X Window sessions spread across multiple terminals powered by a single machine – this is an example of the use of thin client. Similar functions were also available in a variety of non-Unix-like operating systems, such as Multics, VM/CMS, OpenVMS, MP/M, Concurrent CP/M, Concurrent DOS, FlexOS, Multiuser DOS, REAL/32, OASIS, THEOS, PC-MOS, TSX-32 and VM/386.
Some multi-user operating systems such as Windows versions from the Windows NT family support simultaneous access by multiple users (for example, via Remote Desktop Connection) as well as the ability for a user to disconnect from a local session while leaving processes running (doing work on their behalf) while another user logs into and uses the system. The operating system provides isolation of each user's processes from other users, while enabling them to execute concurrently[dubious – discuss].
Management systems are implicitly designed to be used by multiple users, typically at least one system administrator or system operator, and an end-user community.
The complementary term, single-user, is most commonly used when talking about an operating system being usable only by one person at a time, or in reference to a single-user software license agreement. Multi-user operating systems such as Unix sometimes have a single user mode or runlevel available for emergency maintenance. Examples of single-user operating systems include MS-DOS, OS/2 and Classic Mac OS.
See also
[edit]References
[edit]- ^ Red, Edward; Jensen, Gregory; French, David; Weerakoon, Prasad (10 October 2011). Multi-User Architectures for Computer-Aided Engineering Collaboration. 2011 17th International Conference on Concurrent Enterprising, ICE 2011. ResearchGate. Retrieved 6 October 2022.
External links
[edit]- Interix in a Multi-User Windows TSE Environment paper about the Unix multi-user model and MS-Windows NT TSE
Multi-user software
View on Grokipediafrom Grokipedia
Multi-user software refers to computer programs or systems designed to support concurrent access and interaction by multiple users, typically in networked or shared environments, enabling efficient resource utilization, collaboration, and data management while maintaining system integrity through mechanisms like concurrency control.[1]
The concept originated in the early 1960s with time-sharing systems, which allowed multiple users to share a single computer's processing power via terminals; notable early examples include MIT's Compatible Time-Sharing System (CTSS) in 1963, supporting up to 30 users, and the Multics system by 1965, which scaled to 300 terminals and influenced modern operating systems like UNIX.[1] Over time, multi-user software evolved with advancements in networking, such as local area networks (LANs) in the 1980s, shifting focus toward client-server architectures, distributed systems, and collaborative tools to handle growing demands for simultaneous access in enterprise and online settings.[1]
Key features of multi-user software include resource sharing (e.g., files, printers, and databases), time-sharing for allocating CPU cycles, background processing to handle tasks without user interruption, and robust security measures like user authentication and access permissions to prevent conflicts and ensure data consistency.[2] Examples span operating systems like UNIX, which supports multiple concurrent logins, to applications such as Google Docs for real-time collaborative editing, Skype for multi-party communication, and online multiplayer games that manage thousands of simultaneous interactions.[1] These systems address challenges like scalability and concurrency, making them essential in fields ranging from business (e.g., ERP software) to education and entertainment, while promoting economic efficiency through shared infrastructure.[2]
Definition and Fundamentals
Core Definition
Multi-user software refers to computer programs or systems designed to permit multiple users to access, interact with, and share the same resources or application concurrently, ensuring that each user's actions do not unduly interfere with others.[3] This capability distinguishes it from environments limited to individual use, emphasizing efficient resource allocation and collaborative functionality across diverse computing setups.[4] At its core, multi-user software relies on shared resources such as databases, file systems, or central processing units to support simultaneous operations by various users.[1] Essential components include robust user authentication mechanisms to verify identities and prevent unauthorized access, as well as session management protocols that track and maintain individual user interactions over time.[5] These elements enable secure, persistent connections, allowing users to maintain stateful engagements without disrupting the overall system integrity. The scope of multi-user software extends to both local access models, exemplified by time-sharing systems where users connect via terminals to a single host, and remote models, such as cloud-based platforms that facilitate distributed collaboration over networks.[6]Distinction from Single-User Software
Single-user software is designed for operation by a single individual at a time, typically running on a personal device with no inherent mechanisms for concurrent access by others. Such applications, like standalone desktop text editors or basic image processing tools, assume exclusive control by one user, limiting their use to isolated environments without network-based sharing. In contrast, multi-user software supports simultaneous access and interaction by multiple individuals, often through networked architectures that enable collaboration or resource distribution. Key distinctions include resource management, where single-user software maintains isolation of files, memory, and processing to prevent interference—suitable for personal tasks—while multi-user systems implement sharing protocols to allocate resources dynamically among users, enhancing efficiency in group settings but introducing complexity in coordination. Authentication mechanisms also differ markedly: single-user applications rarely require user verification since access is unrestricted for the sole operator, whereas multi-user software mandates robust identity checks, such as login credentials or tokens, to ensure authorized participation and protect shared data. Scalability represents another divide; single-user software faces inherent limits in handling increased load, performing optimally for one user but degrading under parallel demands, whereas multi-user designs incorporate expandable structures to accommodate growing numbers of participants without proportional performance loss.[4][7] A notable example of transitioning from single-user to multi-user paradigms is the evolution of word processing tools. Early programs like WordStar, released in 1978, operated as standalone single-user applications on personal computers, allowing one person to edit documents without collaborative features.[8] Over time, these evolved into cloud-based multi-user versions, such as Google Docs launched in 2006, which permits real-time editing by multiple users on a shared document, transforming isolated workflows into collaborative ones.[9] These differences carry significant implications for system design and operation. Multi-user software must address potential conflicts arising from concurrent access, such as implementing data locking mechanisms—where exclusive locks prevent overlapping modifications to the same resource—to maintain integrity, a concern absent in single-user setups where no such overlaps occur. Failure to manage these can lead to data corruption or inconsistencies, underscoring the added overhead in multi-user environments.[10]Historical Development
Origins in Mainframe Computing
The development of multi-user software traces its roots to the mainframe computing era of the 1950s and 1960s, when large-scale computers were primarily used for batch processing in scientific and business applications.[11] Early mainframes, such as the IBM 701 introduced in 1952, operated in a non-interactive mode where jobs were submitted in batches via punched cards or tape, processed sequentially, and output generated without real-time user intervention. This approach limited efficiency for multiple users, as the system remained idle between jobs, prompting researchers to explore ways to share computing resources more dynamically.[12] A pivotal shift occurred in the early 1960s with the advent of time-sharing systems, which enabled multiple users to interact with a single mainframe concurrently through remote terminals. The Compatible Time-Sharing System (CTSS), developed at MIT on a modified IBM 709 in 1961 and operational by 1963, marked one of the first practical implementations, allowing up to 30 users to access the system simultaneously via typewriter terminals without significant interference.[12] This innovation evolved from batch processing by introducing rapid job switching—typically every 100-200 milliseconds—facilitating interactive computing and laying the groundwork for multi-user environments. CTSS demonstrated that mainframes could support conversational access, influencing subsequent designs by prioritizing user responsiveness over strict job isolation.[12] In the mid-1960s, landmark projects further advanced multi-user capabilities. The Multics (Multiplexed Information and Computing Service) operating system, initiated in 1965 as a collaboration between MIT's Project MAC, Bell Telephone Laboratories, and General Electric's Large Computer Product Line, pioneered secure, scalable multi-user access on the GE-645 mainframe, with the first operational version running in 1967.[13] Multics introduced innovations like virtual memory, segmented addressing, and hierarchical file protection, enabling isolated user sessions and controlled resource sharing among dozens of simultaneous terminal users.[14] Its design, detailed in the seminal 1965 paper "Introduction and Overview of the Multics System," emphasized a "computer utility" model for reliable multi-user service. Concurrently, IBM's System/360, announced in 1964, provided the architectural foundation for multi-user operations through its compatible family of processors, with the Time-Sharing System (TSS/360) released in 1968 to support interactive access for multiple users on models like the System/360 Model 67.[11] TSS/360 built on OS/360's batch-oriented framework by incorporating virtual storage and priority scheduling to manage concurrent user sessions efficiently.[15] These early systems established core principles of multi-user software, including user isolation via memory protection and fair resource allocation through time-slicing and paging mechanisms.[13] Multics, in particular, set standards for secure access control, influencing resource management techniques that prevented one user's processes from disrupting others.[14] By the late 1960s, time-sharing had transformed mainframes from single-job processors into shared platforms, supporting up to 100 users in some installations and paving the way for conceptual advancements in concurrency.[12]Evolution with Networking and the Internet
The development of multi-user software in the 1970s and 1980s was profoundly influenced by early networking advancements, particularly the ARPANET, which facilitated remote access to shared computing resources across geographically dispersed users. Launched in 1969 by the U.S. Department of Defense's Advanced Research Projects Agency (DARPA), ARPANET introduced packet-switching technology that enabled time-sharing systems to support multiple simultaneous users through protocols like Telnet for remote login and file transfer, allowing researchers to access high-cost mainframes from distant locations.[16] This built on mainframe time-sharing concepts by extending them over wide-area networks, promoting collaborative multi-user environments in academic and military settings. Concurrently, UNIX operating systems, originally developed at Bell Labs in 1969, inherently supported multi-user access through its design for time-sharing and multitasking, with remote capabilities enhanced via ARPANET connections in the early 1970s.[17] A pivotal contribution during this era was the Berkeley Software Distribution (BSD), an open-source variant of UNIX released starting in 1978 by the University of California, Berkeley, which became a cornerstone for networked multi-user operating systems. BSD integrated TCP/IP protocols in the early 1980s under DARPA funding, enabling robust remote multi-user access over ARPANET and laying the groundwork for Unix-like systems to handle distributed users efficiently.[18][16] By the mid-1980s, the adoption of TCP/IP as the standard protocol suite for ARPANET in 1983 marked a shift from local terminal-based interactions to internetworked multi-user sessions, allowing thousands of users to share resources via protocols that ensured reliable data transmission across heterogeneous systems.[19] In the 1990s, the rise of the World Wide Web (WWW), proposed by Tim Berners-Lee at CERN in 1989 and made publicly available in 1991, revolutionized multi-user software by enabling browser-based interactions with centralized databases, shifting from proprietary networks to open web protocols. This era saw the proliferation of client-server databases, such as Oracle Database Version 6 released in 1988, which supported multi-user concurrency through row-level locking, allowing multiple users to query and update shared data in real-time.[20][21] Oracle's advancements, including PL/SQL for server-side processing introduced in 1988, facilitated scalable web applications that handled concurrent user sessions, exemplified by tools like Oracle PowerBrowser in 1996 for web-enabled database interactions.[21] From the 2000s onward, cloud computing and Software as a Service (SaaS) models transformed multi-user software into globally accessible, on-demand services capable of supporting vast numbers of concurrent users. Amazon Web Services (AWS) launched in 2006 with Amazon Simple Storage Service (S3) and Elastic Compute Cloud (EC2), providing scalable infrastructure that allowed developers to deploy multi-user applications without managing physical hardware, enabling rapid provisioning for thousands of simultaneous users worldwide.[22] SaaS emerged as a dominant paradigm around 2000, with pioneers like Salesforce introducing cloud-hosted CRM in 1999, evolving through the 2000s to offer multi-tenant architectures where a single instance serves multiple organizations securely and scalably.[23] Virtualization technologies, revitalized in the early 2000s by products like VMware ESX Server (2001), further amplified this by allowing multiple virtual machines to run concurrently on shared hardware, optimizing resource allocation for high-concurrency multi-user environments in cloud settings.[24] These trends underscored a broader evolution from localized, terminal-driven multi-user systems to internet-scale, virtualized platforms governed by TCP/IP, democratizing access and enhancing scalability for global collaboration.[25]Architectural Models
Client-Server Architecture
The client-server architecture serves as a cornerstone for multi-user software, dividing responsibilities between clients—typically lightweight user interfaces on end-user devices—and centralized servers that manage shared resources, data, and processing logic across a network. In this model, clients initiate requests for services, such as data retrieval or computation, while the server responds by fulfilling those requests, enabling multiple users to interact with the same system simultaneously without direct peer interactions. This separation promotes efficiency in distributed environments, where the server acts as the authoritative hub for maintaining system integrity and resource sharing.[26] Key components include the client, which provides a thin interface for user input and display (e.g., web browsers or dedicated applications), and the server, which performs essential tasks like user authentication to verify identities and data processing to execute operations on shared datasets. Authentication on the server ensures secure access for multiple users, often through protocols that validate credentials before granting permissions, while data processing involves querying, updating, and storing information in a centralized manner to support collaborative use. This division allows clients to remain resource-light, focusing on presentation, as the server bears the computational load for multi-user coordination.[26][27] Communication in client-server systems relies on standardized protocols to facilitate reliable exchanges; for instance, HTTP and HTTPS enable web-based clients to send requests and receive responses over the internet, with HTTPS adding encryption for secure multi-user sessions. Database interactions commonly use SQL, where clients submit queries to the server for execution against shared databases, allowing efficient handling of concurrent data access from multiple users. To scale for high concurrency, load balancing distributes client requests across server clusters, optimizing performance and availability by routing traffic to less burdened instances.[27][28] Practical implementations abound in web applications, such as email servers like Microsoft Exchange, which leverage client-server design to support multiple simultaneous logins from clients using protocols like HTTP, enabling users to access shared mailboxes and process messages centrally on the server. This architecture, which traces its conceptual roots to early networked systems like UNIX, underpins much of modern multi-user software by centralizing control for reliability and ease of management.[29][26]Peer-to-Peer Systems
In peer-to-peer (P2P) systems, each node functions as both a client and a server, enabling direct resource sharing among participants without reliance on a central authority. This distributed structure allows users to exchange data, files, or computational resources symmetrically, promoting scalability in multi-user environments where participants contribute equally to the network's operation. Unlike centralized models, P2P architectures distribute control and storage across all nodes, reducing bottlenecks and enhancing resilience through collective participation.[30] Key components of P2P systems include decentralized routing mechanisms, such as Distributed Hash Tables (DHTs), which map keys to node identifiers in a structured overlay network to facilitate efficient lookups. DHTs, exemplified by the Chord protocol, organize nodes into a ring topology where each maintains routing information for a subset of the identifier space, enabling logarithmic-time searches even as the network scales to millions of nodes. Self-organizing networks further support fault tolerance by allowing nodes to dynamically join, leave, or recover from failures through local coordination, ensuring the system maintains connectivity and data availability without manual intervention.[31] Prominent P2P protocols illustrate these principles in practice. The BitTorrent protocol employs a DHT-based trackerless mode for file sharing, where peers download and upload pieces of content simultaneously, leveraging tit-for-tat incentives to encourage cooperation and achieve high throughput in large-scale distributions. Similarly, blockchain-based P2P networks, as introduced in Bitcoin, use a distributed ledger maintained by consensus among nodes to enable secure, decentralized transactions without intermediaries, relying on proof-of-work to validate peer interactions.[32][33] In multi-user contexts, P2P systems facilitate large-scale collaboration by eliminating single points of failure, allowing applications to operate robustly across distributed users. For instance, early versions of Skype utilized a hybrid P2P architecture for voice calls, where ordinary nodes relay media streams directly when possible, supporting millions of concurrent users through supernode selection for NAT traversal and efficient routing. This approach underscores P2P's role in enabling fault-tolerant, collaborative software that scales with participant growth.Technical Implementation
Concurrency and Resource Management
In multi-user software environments, concurrency arises when multiple users or processes access shared resources simultaneously, leading to potential issues such as race conditions and deadlocks. A race condition occurs when the outcome of operations depends on the unpredictable timing or interleaving of threads, potentially resulting in inconsistent data states, as seen in multithreaded programs where shared variables are modified without proper synchronization.[34] Deadlocks emerge when two or more processes hold resources while waiting for others held by each other, creating a circular dependency that halts progress, a common problem in resource-contested systems like databases or networked applications.[35] To manage these concurrency challenges, multi-user software employs threading models and locking mechanisms. In languages like Java, multi-threading allows concurrent execution through the Thread class and Runnable interface, enabling applications to handle multiple user requests efficiently via the Java Virtual Machine's support for parallel threads.[36] Locking techniques address data integrity: pessimistic locking acquires locks before operations to prevent conflicts, ensuring exclusive access but risking reduced throughput in high-contention scenarios; optimistic locking, conversely, assumes low conflict and validates changes post-operation, using versioning to detect and abort conflicting updates, which improves performance in read-heavy multi-user workloads.[37] Resource allocation in multi-user operating systems involves CPU scheduling and memory paging to equitably distribute hardware among users. CPU scheduling algorithms, such as priority-based or round-robin methods, determine which process runs next on the processor, balancing responsiveness for interactive multi-user tasks while preventing starvation. Memory paging divides virtual address spaces into fixed-size pages mapped to physical frames, allowing non-contiguous allocation that supports multiple users without fragmentation, with the operating system handling page faults to swap pages between memory and disk as needed.[38] A key metric for evaluating such systems is throughput, calculated as , where is the number of concurrent users and is the average response time, derived from Little's Law in queueing theory to quantify system capacity under load. Databases in multi-user software mitigate concurrency via transaction mechanisms adhering to ACID properties. Transactions ensure atomicity (all-or-nothing execution), consistency (state transitions from one valid state to another), isolation (concurrent transactions appear serial), and durability (committed changes persist despite failures), enabling reliable shared data access in environments like client-server systems.[39]Security and Access Control
In multi-user software environments, access control models are critical for regulating user permissions to resources, ensuring that only authorized individuals can perform specific actions. Role-Based Access Control (RBAC) assigns permissions to roles rather than individual users, simplifying administration in systems where multiple users share common responsibilities, such as in enterprise databases or collaborative platforms.[40] This model originated in the 1970s for multi-user online systems and has evolved into standards like NIST's RBAC framework, which includes core components for role hierarchies and separation of duties to prevent conflicts.[40] In contrast, Mandatory Access Control (MAC) enforces system-wide policies based on security labels assigned to subjects and objects, often used in high-security multi-user operating systems like SELinux to restrict information flow and mitigate unauthorized data access.[41] MAC policies, such as Bell-LaPadula for confidentiality, ensure that decisions are made by the system rather than users, providing robust protection in shared environments.[41] Authentication methods in multi-user software verify user identities to prevent unauthorized entry into shared systems. Multi-factor authentication (MFA) requires at least two distinct factors—such as something known (e.g., password), possessed (e.g., token), or inherent (e.g., biometrics)—to strengthen security beyond single-factor methods, significantly reducing risks in collaborative applications.[42] For instance, NIST guidelines recommend MFA for moderate assurance levels in remote access scenarios common to multi-user setups.[43] OAuth, an authorization framework, enables secure delegated access to APIs in multi-user applications without sharing credentials, allowing third-party integrations while maintaining user control over permissions.[44] This protocol supports advanced authentication like MFA integration, making it suitable for web-based multi-user services.[44] Multi-user software faces unique threats due to concurrent access, including session hijacking, where attackers intercept active user sessions to impersonate legitimate users, often exploiting unencrypted communications.[45] Privilege escalation occurs when a user or malware exploits vulnerabilities to gain higher access levels than intended, potentially compromising the entire shared system, as seen in attacks targeting trusted applications.[46] To counter these, encryption standards like Transport Layer Security (TLS) secure data in transit, using protocols such as TLS 1.3 with AES-GCM cipher suites to prevent interception in multi-user network interactions.[47] RFC recommendations emphasize TLS implementation with perfect forward secrecy to protect against key compromise in shared environments.[48] Auditing in multi-user software involves systematic logging of user actions to enable anomaly detection and forensic analysis in shared systems. Comprehensive logs capture events like access attempts and resource modifications, allowing administrators to review trails for compliance and security.[49] Techniques such as behavior-based anomaly detection analyze these logs to identify deviations from normal patterns, such as unusual privilege escalations, using statistical models on access data from electronic health record systems.[50] NIST guidelines advocate configuring audits to include both successful and failed events, facilitating real-time monitoring and post-incident investigations in multi-user contexts.[49]Practical Applications and Examples
Multi-User Operating Systems
Multi-user operating systems are designed to enable simultaneous access to system resources by multiple users, often through time-sharing mechanisms that allocate CPU, memory, and peripherals efficiently among concurrent sessions.[51] These systems originated from early time-sharing projects, with Multics serving as a key influence on UNIX, which was developed starting in 1969 at Bell Labs and reached a significant milestone by November 1971 when its core components were compiled into a functional system.[52] UNIX's design emphasized modularity and portability, allowing it to support multiple users via remote logins and virtual environments, a capability that persists in modern derivatives.[53] Prominent examples include UNIX and Linux variants, such as Ubuntu Server, which facilitate multiple user logins over networks using protocols like SSH for secure remote access.[54] In enterprise settings, Windows Server editions support multi-user scenarios by permitting concurrent sign-ins, often via Remote Desktop Services, enabling shared device usage in environments like offices or kiosks.[55] Similarly, macOS, built on a UNIX foundation, provides multi-user support through distinct user accounts and groups, allowing shared access to the same hardware while maintaining isolated profiles for settings and files.[56] Core features of these systems include robust user account management, where each user receives a unique identifier with associated home directories and profiles to ensure isolation.[57] Permissions systems, such as thechmod command in UNIX-like environments, control access to files and directories by specifying read, write, and execute rights for owners, groups, and others, preventing unauthorized modifications.[58] Virtual terminals further enhance multi-user functionality by providing multiple console sessions—accessible via key combinations like Ctrl+Alt+F1 through F6 in Linux—allowing independent logins without interfering with graphical interfaces or other users.[59] These elements rely on kernel-level concurrency to manage processes across users, ensuring fair resource allocation.[51]
In practice, multi-user operating systems power servers in data centers, where they host virtual users for tasks like web hosting and database management, optimizing hardware utilization across thousands of concurrent sessions.[60] For instance, Linux-based servers in such facilities provide a centralized interface for managing diverse user access, supporting scalable deployments for cloud services and enterprise applications.[61]