Editing History of operating systems (section)

==Background==
{{More citations needed section|date=April 2025}}

Early computers lacked any form of operating system. Instead, the user, also called the operator, had sole use of the machine for a scheduled period of time. The operator would arrive at the computer with program and data which needed to be loaded into the machine before the program could be run. Loading of program and data was accomplished in various ways including toggle switches, [[Punched card|punched paper cards]] and magnetic or paper tape.<ref>{{Cite web |title=Computers {{!}} Timeline of Computer History {{!}} Computer History Museum |url=https://www.computerhistory.org/timeline/computers/ |archive-url=http://web.archive.org/web/20241225013827/https://www.computerhistory.org/timeline/computers/ |archive-date=2024-12-25 |access-date=2025-01-01 |website=www.computerhistory.org}}</ref><ref>{{Cite web |title=The punched card {{!}} IBM |url=https://www.ibm.com/history/punched-card |access-date=2025-01-01 |website=www.ibm.com}}</ref><ref>{{Cite web |date=2021-02-09 |title=When Computer Coding Was a 'Woman's' Job |url=https://www.history.com/news/coding-used-to-be-a-womans-job-so-it-was-paid-less-and-undervalued |access-date=2025-01-01 |website=HISTORY}}</ref>  Once loaded, the machine would be set to execute the single program until that program completed or crashed. Programs could generally be debugged via a control panel using dials, toggle switches and panel lights, making it a very manual and error-prone process.<ref>{{Cite journal |last=Stuart |first=Brian |date=December 2018 |title=Debugging the ENIAC [Scanning Our Past] |url=https://ieeexplore.ieee.org/document/8540483 |journal=Proceedings of the IEEE |volume=106 |issue=12 |pages=2331–2345 |doi=10.1109/JPROC.2018.2878986}}</ref>

Symbolic languages, [[assembly language|assemblers]],<ref>{{cite book
 | title   = 705 Autocoder System Macro Instruction Manual
 | id      = 22-6726-1
 | date    = February 1957
 | edition = second
 | url     = http://bitsavers.org/pdf/ibm/705/22-6726-1_autocoder_Feb57.pdf
 | mode    = cs2}}</ref><ref>{{cite book
 | title = The USE Compiler Programming Manual for the UNIVAC Scientific 1103A and 1105 Computers
 | url   = http://bitsavers.org/pdf/univac/1103/use/U1869_USE_compiler.pdf
 | mode  = cs2}}</ref><ref>{{cite book
 | title = A Programmer's Guide to the X-6 Assembly System
 | id = U 1774.1
 | url = http://bitsavers.org/pdf/univac/uss/U1774.1_X-6_Assembler_Introduction.pdf
 | mode = cs2}}</ref> [[compiler]]s were developed for programmers to translate symbolic program code into [[machine code]] that previously would have been hand-encoded. Later machines came with [[runtime library|libraries]] of support code on punched cards or magnetic tape, which would be linked to the user's program to assist in operations such as input and output. This was the genesis of the modern-day operating system; however, machines still ran a single program or job at a time. At [[University of Cambridge|Cambridge University]] in England the [[job queue]] was at one time a string from which tapes attached to corresponding job tickets were hung with stationery pegs.<ref>{{Cite web |title=Video & Audio: The EDSAC Film - Metadata |url=https://sms.cam.ac.uk/media/739532 |access-date=2023-06-21 |website=sms.cam.ac.uk}}</ref>

As machines became more powerful the time to run programs diminished, and the time to hand off the equipment to the next user became large by comparison. Accounting for and paying for machine usage moved on from checking the wall clock to automatic logging by the computer. Run queues evolved from a literal queue of people at the door, to a heap of media on a jobs-waiting table, or batches of punched cards stacked one on top of the other in the reader, until the machine itself was able to select and sequence which [[magnetic tape]] drives processed which tapes. Where program developers had originally had access to run their own jobs on the machine, they were supplanted by dedicated machine operators who looked after the machine and were less and less concerned with implementing tasks manually. When commercially available computer centers were faced with the implications of data lost through tampering or operational errors, equipment vendors were put under pressure to enhance the runtime libraries to prevent misuse of system resources. Automated monitoring was needed not just for [[central processing unit|CPU]] usage but for counting pages printed, cards punched, cards read, disk storage used and for signaling when operator intervention was required by jobs such as changing magnetic tapes and paper forms. Security features were added to operating systems to record [[audit trail]]s of which programs were accessing which files and to prevent access to a production payroll file by an engineering program, for example.

All these features were building up towards the repertoire of a fully capable operating system. Eventually the [[runtime library|runtime libraries]] became an amalgamated program that was started before the first customer job and could read in the customer job, control its execution, record its usage, reassign hardware resources after the job ended, and immediately go on to process the next job. These resident background programs, capable of managing multi step processes, were often called [[resident monitor|monitor]]s or monitor-programs before the term "operating system" established itself.

An underlying program offering basic hardware management, software scheduling and resource monitoring may seem a remote ancestor to the user-oriented OSes of the [[personal computer|personal computing]] era. But there has been a shift in the meaning of OS. Just as early automobiles lacked speedometers, radios, and air conditioners which later became standard, more and more optional software features became standard in every OS package. This has led to the perception of an OS as a complete user system with an integrated [[graphical user interface]], utilities, and some applications such as [[file manager]]s, [[text editor]]s, and configuration tools.

The true descendant of the early operating systems is what is now called the "[[kernel (operating system)|kernel]]". In technical and development circles the old restricted sense of an OS persists because of the continued active development of [[embedded system|embedded]] operating systems for all kinds of devices with a data-processing component, from hand-held gadgets up to industrial robots and [[real-time computing|real-time]] control systems, which do not run user applications at the front end. An embedded OS in a device today is not so far removed as one might think from its ancestor of the 1950s.

The broader categories of systems and application software are discussed in the [[software|computer software]] article.