The first operating systems started to appear with the arrival of second generation computers in the mid-fifties to early sixties. At that time, computers had reached a level of complexity that made it no longer possible to write every program from scratch. The solution was to abstract commonly encountered tasks into a set of routines that could be used by any program. These routines were typically provided as part of the runtime system of a programming language such as FORTRAN. While this avoided having to write each program from ground-up, it still resulted in much duplicated efforts in writing each runtime system. Abstracting and factoring the common functionality present in each runtime system led to language-independent run-time systems, which were arguably the first, albeit primitive, operating systems. The noteworthy point is that the boundary between the operating system and the application does not follow from any kind of natural law, but instead is a contrived entity. Consequently, the study of operating systems not only involves the study of how the desired operating system services should be provided, but also what services should be present in the first place.
Not surprisingly, the what and how of operating systems changed over the decades as computers became ever more powerful. For example, with the arrival of batch-oriented systems, job-control languages were added to the operating systems. These job-control languages made it possible to specify the requirements and actions of a compute-job off-line, thus leading to greatly increased utilization of the expensive central processing unit (CPU). Utilization was further improved by the introduction of multi-programming. Multi-programming allowed the system to keep multiple jobs in the core-memory so the idle-time of a job that arises from its input/output requests and other synchronization constraints could be filled with computation from other jobs. This improved utilization, but unfortunately also increased job completion time. In 1962, the CTSS operating system introduced time-sharing to alleviate this problem [21]. Time-sharing made it possible give short jobs higher priority than long-running batch jobs. This preserved the high utilization of batch-processing while greatly reducing the job completion time for short jobs. More importantly, however, time-sharing made it possible for the first time to have multiple users work with a computer interactively. This fundamentally changed how programmers and users perceived computer systems.
The evolution of time-sharing systems culminated in the development of MULTICS, a system designed to support hundreds of simultaneous users [22]. MULTICS aimed to be everything to everybody and its extant complexity caused repeated and excessive delays. Even though it eventually shipped to a few customers, it was widely considered a commercial failure. Nevertheless, it laid the foundation for much of the operating system research of the coming thirty years. There continued to be dramatic technological advances, such as the introduction of the mini-computers, then micro- and personal-computers (PCs), but the fundamental structure of operating systems has remained remarkably unchanged since. To be sure, all modern operating systems support networking and are, in a sense, part of a world-wide distributed system, but the fundamental abstraction of these systems was, and is, the process---an abstraction that computes.