Historia y evolución de los sistemas operativos

1. Por qué mirar hacia atrás

En el tema 2 vimos qué problemas resuelve un sistema operativo. Pero esos problemas no aparecieron todos juntos, ni las soluciones tampoco. Las interrupciones, el modo kernel, los procesos o la memoria virtual pueden parecer una lista arbitraria de mecanismos cuando se estudian por primera vez; vistos en orden histórico, cada uno resulta ser la respuesta razonable a una dificultad que la etapa anterior dejó sin resolver.

Hay un hilo que recorre toda la historia y conviene tenerlo presente desde el principio: qué es lo caro. En los años cincuenta una computadora costaba millones de dólares y el tiempo de las personas, en comparación, casi nada; el objetivo era que la máquina no estuviera ociosa ni un segundo. Hoy la relación se invirtió: el hardware es barato y lo valioso es el tiempo de quien lo usa. Casi todos los cambios de rumbo que veremos se explican por ese desplazamiento.

2. Panorama de las etapas

Las fechas son aproximadas y las etapas se superponen, pero la secuencia de problemas y soluciones es clara:

3. La máquina sin sistema operativo (1945–1955)

Las primeras computadoras no tenían nada que se pareciera a un sistema operativo. Quien quería ejecutar un programa reservaba un turno en una planilla, llegaba a la sala a la hora asignada con sus tarjetas perforadas o su cinta de papel, cargaba el programa a mano, lo ponía en marcha con los interruptores de la consola y esperaba el resultado. Si el programa fallaba, examinaba las luces del panel para averiguar por qué. Era, literalmente, la situación que imaginamos en el tema 1: un programa a solas con el hardware.

El problema era económico. La máquina, carísima, pasaba la mayor parte del tiempo detenida: mientras un programador cargaba sus tarjetas, mientras pensaba dónde estaba el error, mientras el siguiente todavía no llegaba. Y si alguien terminaba antes de tiempo, el resto de su turno se perdía.

De esta etapa quedó una primera idea, anterior al sistema operativo: guardar en bibliotecas las rutinas que todos necesitaban, sobre todo las de entrada y salida, para no reescribirlas en cada programa.

4. Sistemas por lotes (1955–1965)

La solución fue sacar a las personas de la sala. Los programadores entregaban sus trabajos (en inglés, jobs) a un operador, que los agrupaba en un lote y los cargaba juntos en una cinta. En la memoria de la computadora quedaba instalado de forma permanente un pequeño programa, el monitor residente, que hacía una sola cosa: leer el siguiente trabajo de la cinta, cargarlo, cederle el control y, cuando terminaba, recuperarlo para pasar al siguiente sin intervención humana.

Ese monitor es el primer sistema operativo. El ejemplo más citado es GM-NAA I/O, escrito en 1956 por General Motors y North American Aviation para su computadora IBM 704. Con él aparecen dos conceptos que siguen vigentes:

• Un programa que controla a los demás programas y que permanece siempre en memoria. Es el antepasado directo del kernel.
• Un lenguaje de control de trabajos: tarjetas especiales intercaladas con el programa que le indicaban al monitor qué compilador usar o dónde terminaban los datos. Es el antepasado de la shell.

También apareció la primera necesidad de protección. Si un trabajo con errores sobrescribía el monitor, o entraba en un bucle infinito, o leía por error las tarjetas del trabajo siguiente, el lote entero se perdía. La respuesta vino del hardware, que incorporó tres recursos que hoy damos por sentados: una zona de memoria que los programas no pueden tocar, un temporizador que interrumpe a un trabajo demasiado largo, e instrucciones reservadas al monitor. Son, respectivamente, la protección de memoria, las interrupciones de reloj y el modo kernel.

5. Multiprogramación (años sesenta)

El monitor por lotes eliminó los tiempos muertos entre trabajos, pero quedaba otro dentro de cada trabajo. Los dispositivos de entrada y salida son mecánicos y lentísimos comparados con la CPU: mientras se leía una cinta o se imprimía una línea, el procesador no tenía nada que hacer. En programas comerciales, que leen y escriben mucho, la CPU podía pasar ociosa la mayor parte del tiempo.

La multiprogramación consiste en mantener varios trabajos cargados en memoria a la vez. Cuando el que se está ejecutando necesita esperar a un dispositivo, el sistema operativo entrega la CPU a otro. Cuando el dispositivo termina, avisa con una interrupción y el primer trabajo vuelve a estar listo.

La idea es simple; sus consecuencias, enormes. Con varios programas en memoria al mismo tiempo, el sistema operativo tiene que resolver de golpe casi todos los problemas que hoy definen la materia:

• Gestión de memoria: dónde ubicar cada trabajo y cómo impedir que uno invada a otro.
• Planificación de la CPU: si hay varios trabajos listos, cuál se ejecuta.
• Sincronización: qué pasa si dos trabajos quieren la impresora a la vez.
• Memoria virtual: la computadora Atlas, en Manchester (1962), fue la primera en usar el disco como extensión automática de la memoria, para cargar más programas de los que cabían.

El sistema emblemático de la etapa es OS/360 de IBM, anunciado en 1964. Su ambición era nueva: un único sistema operativo para toda una familia de computadoras, de la más pequeña a la más grande, de modo que un programa escrito para una funcionara en las demás. Resultó tan complejo que su desarrollo se convirtió en el caso de estudio fundacional de la ingeniería de software. Su descendiente MVS (1974) añadió memoria virtual, y esa línea continúa en los mainframes actuales.

6. Tiempo compartido (1961–1975)

La multiprogramación exprimía la máquina, pero el programador seguía esperando horas por su listado. A medida que el hardware se abarataba, ese tiempo humano perdido empezó a pesar más que el tiempo de máquina.

El tiempo compartido es una variante de la multiprogramación pensada para personas. Decenas de usuarios se conectan a la misma computadora, cada uno desde una terminal con teclado. El sistema operativo entrega la CPU a cada programa durante una fracción de segundo y pasa al siguiente, sin esperar a que el programa la ceda. Como una persona tarda mucho en escribir y leer, y la máquina es rápida, cada usuario tiene la impresión de disponer de una computadora para él solo. Es la primera aparición de la «ilusión de la máquina propia» del tema anterior.

El primer sistema de este tipo fue CTSS, presentado en el MIT en 1961. Con él cambió la forma de programar: se podía escribir, ejecutar, ver el error y corregir en minutos. También surgieron necesidades nuevas, porque por primera vez varias personas compartían una máquina al mismo tiempo: cuentas de usuario, contraseñas, archivos con dueño y permisos.

El éxito de CTSS dio origen a un proyecto mucho más ambicioso, Multics (1965), del MIT, General Electric y los Laboratorios Bell. Pretendía ser un servicio de cómputo continuo para toda una ciudad, como la red eléctrica. Tardó años, fue comercialmente modesto y aun así es uno de los sistemas más influyentes de la historia: introdujo el sistema de archivos jerárquico en forma de árbol, los anillos de protección y la idea de escribir el sistema en un lenguaje de alto nivel. Su mayor legado, sin embargo, fue involuntario.

7. Unix (1969)

En 1969 los Laboratorios Bell se retiraron de Multics. Dos de sus investigadores, Ken Thompson y Dennis Ritchie, se quedaron sin el entorno cómodo al que se habían acostumbrado y decidieron construirse uno, mucho más pequeño, sobre una minicomputadora PDP-7 que nadie usaba. Lo llamaron Unix, en un juego de palabras con Multics: donde aquel quería hacerlo todo, este haría pocas cosas y bien.

Unix importa en este curso más que ningún otro sistema, porque casi todo lo que estudiaremos sobre Linux viene de él. Sus decisiones de diseño:

• Escrito en un lenguaje de alto nivel. En 1973 se reescribió en C, un lenguaje creado por Ritchie con ese fin. Hasta entonces los sistemas operativos se escribían en ensamblador y morían con su máquina; Unix podía llevarse a otro hardware recompilándolo. Es el origen de la estrecha relación entre C y los sistemas operativos.
• Todo es un archivo. Archivos, dispositivos y canales de comunicación se manejan con las mismas pocas operaciones: abrir, leer, escribir y cerrar. Es lo que permitió que el programa copiar del tema 2 funcionara con cualquier origen.
• Herramientas pequeñas que se combinan. Cada programa hace una sola cosa, y la tubería (1973) conecta la salida de uno con la entrada de otro.
• La shell es un programa común. El intérprete de comandos no forma parte del kernel, así que cualquiera puede reemplazarlo por otro.
• Un kernel reducido con un conjunto pequeño de llamadas al sistema, fácil de entender completo.

Por razones legales, Bell no podía vender software y entregó Unix a las universidades con su código fuente. Una generación de estudiantes aprendió sistemas operativos leyéndolo y modificándolo. De ahí salieron dos grandes ramas: BSD, de la Universidad de California en Berkeley, que aportó entre otras cosas los sockets de red, y System V, la versión comercial. Sobre ellas se construyeron sistemas como SunOS para estaciones de trabajo y Xenix, el Unix de Microsoft.

Tantas variantes resultaron incompatibles entre sí, y en 1988 se publicó el estándar POSIX, que fija qué llamadas al sistema y qué comandos debe ofrecer un sistema «tipo Unix». Los programas en C de este curso usan esa interfaz; la vemos en el tema 15.

8. Computadoras personales (1975–1990)

El microprocesador hizo posible una computadora que una persona podía comprar. Pero esas primeras máquinas eran mínimas: unos pocos kilobytes de memoria, sin disco rígido y con un procesador que carecía de modo privilegiado y de protección de memoria.

Sus sistemas operativos fueron, en consecuencia, un retroceso de veinte años respecto de lo que ya existía en los equipos grandes. CP/M (1974) y MS-DOS (1981), el sistema de la IBM PC, ejecutaban un solo programa a la vez, para un solo usuario y sin ninguna protección: cualquier programa podía escribir en cualquier dirección de memoria, incluida la del propio sistema, y acceder al hardware directamente. Un error en una aplicación colgaba la máquina entera, y esa misma libertad es la que aprovecharon los primeros virus.

No fue una mala decisión de diseño, sino la única posible. Y deja una lección que repetiremos en todo el curso: lo que un sistema operativo puede garantizar depende de lo que el hardware le permite. Sin un procesador que distinga modo usuario de modo kernel, no hay forma de impedir que un programa haga lo que quiera.

A cambio, estos sistemas trajeron algo nuevo: un mercado de software. Como CP/M y MS-DOS ocultaban las diferencias entre equipos de distintos fabricantes, un mismo programa podía venderse para todos.

9. La interfaz gráfica

Hasta aquí, usar una computadora significaba escribir comandos. En el centro de investigación de Xerox en Palo Alto se desarrolló en 1973 una alternativa: la computadora Alto, con ventanas, iconos y un ratón. Apple llevó esas ideas al mercado con Lisa (1983) y, con éxito masivo, con el Macintosh (1984).

Para el sistema operativo, la interfaz gráfica significó un cambio en el objetivo: ya no se trataba de aprovechar la máquina, sino de responder de inmediato a una persona. El equipo pasa casi todo el tiempo esperando un clic, y cuando llega debe reaccionar al instante. Otros sistemas de la época avanzaron en esa dirección: AmigaOS (1985) ofreció multitarea real en una computadora hogareña, y NeXTSTEP (1989) combinó una base Unix con una interfaz gráfica avanzada.

En el tema 1 dijimos que el escritorio no es la parte esencial de un sistema operativo. La historia lo confirma: la interfaz gráfica llegó décadas después que el kernel, y se montó sobre él como una capa más.

10. Los sistemas modernos llegan a la PC (1985–2005)

En 1985 Intel presentó el procesador 80386, con modo protegido y memoria virtual. Por primera vez una PC tenía el hardware necesario para un sistema operativo como los de los equipos grandes. Faltaba escribirlo, y llegó por dos caminos.

El camino abierto: GNU y Linux

En 1983 Richard Stallman había iniciado el proyecto GNU para construir un sistema tipo Unix completo y libre. Hacia 1990 tenía casi todo —compilador, shell, utilidades— excepto el kernel. Por otro lado, Andrew Tanenbaum había escrito en 1987 MINIX, un Unix pequeño para enseñar sistemas operativos. En 1991 un estudiante finlandés, Linus Torvalds, que usaba MINIX en su 386, empezó a escribir su propio kernel y lo publicó en Internet. Ese kernel, Linux, se combinó con las herramientas de GNU para formar un sistema completo. Es la razón histórica de la distinción entre kernel y distribución que vimos en el tema 1, y de que el compilador que usarás se llame gcc.

El camino comercial: Windows NT

Microsoft, por su parte, encargó un sistema nuevo desde cero. Windows NT (1993) tenía todo lo que le faltaba a MS-DOS: modo kernel, protección de memoria, multitarea real y varios usuarios. Durante años convivió con la línea hogareña de Windows 95, que seguía apoyándose en MS-DOS para mantener la compatibilidad, hasta que Windows XP (2001) unificó ambas sobre el kernel de NT. Todas las versiones actuales de Windows descienden de él.

Apple recorrió un camino parecido: en 2001 reemplazó su sistema clásico por Mac OS X, construido sobre NeXTSTEP y, por lo tanto, sobre Unix.

Hacia 2005, los tres grandes sistemas de escritorio compartían ya los mismos fundamentos, heredados de los años sesenta y setenta. Son los que estudia este curso.

11. Móviles (1996–hoy)

Los primeros dispositivos de mano, como los que usaban Palm OS (1996), repitieron la historia de la PC: hardware limitado y sistemas simples, de una tarea por vez. Cuando los teléfonos tuvieron potencia suficiente, adoptaron directamente kernels de escritorio: iOS (2007) usa el mismo núcleo que macOS, y Android (2008) usa el kernel de Linux.

Lo nuevo no está en el kernel, sino en las restricciones que impone el dispositivo:

• La energía es un recurso más. El sistema operativo administra la batería igual que la CPU o la memoria, y suspende o finaliza las aplicaciones que no están a la vista.
• Ninguna aplicación es de confianza. En una PC, un programa puede hacer todo lo que puede hacer el usuario que lo ejecuta. En un teléfono, cada aplicación corre aislada de las demás y debe pedir permiso explícito para usar la cámara, los contactos o la ubicación.
• El usuario no administra el sistema. No hay archivos de configuración ni instalación manual; el sistema se actualiza y se mantiene solo.

12. Multinúcleo, virtualización y nube (2005–hoy)

Alrededor de 2005 los procesadores dejaron de ganar velocidad y empezaron a multiplicar sus núcleos. Para el sistema operativo, eso convirtió en habitual algo que antes era raro: varios programas ejecutándose realmente al mismo tiempo, y no por turnos. La planificación y la sincronización, temas de los cursos 6 y 7, se volvieron bastante más delicadas.

Un servidor con decenas de núcleos, además, casi nunca se aprovecha con una sola carga de trabajo. La respuesta fue volver a una idea de los años sesenta. IBM había demostrado en 1967 que una computadora podía simular varias copias de sí misma, cada una con su propio sistema operativo. Esa técnica, la virtualización, renació en las PC con VMware (1999), Xen (2003) y KVM (2007), y es la base de la computación en la nube: cuando alquilas un servidor, recibes una máquina virtual que comparte el hardware con las de otros clientes.

Los contenedores, popularizados por Docker en 2013, llevan el reparto un paso más allá: en lugar de simular una máquina completa, aíslan grupos de procesos dentro de un mismo kernel de Linux, lo que resulta mucho más liviano.

Conviene notar la simetría. El tiempo compartido repartía una computadora cara entre muchas personas; la nube reparte un centro de datos caro entre muchos clientes. Es el mismo problema y la misma solución, la ilusión de la máquina propia, aplicados una capa más arriba. Los estudiamos en el curso 13 de esta ruta.

13. Patrones que se repiten

Más que las fechas, de este recorrido conviene retener cuatro regularidades, porque ayudan a entender lo que viene y también lo que todavía no existe.

1. Cambia lo que es caro, y con ello el objetivo. Cuando lo caro era la máquina, el sistema operativo buscaba no desperdiciarla. Cuando lo caro pasó a ser el tiempo de las personas, buscó responder rápido. En un teléfono lo escaso es la batería; en la nube, el costo por cliente.
2. Cada nueva clase de equipo recorre la historia otra vez. Los mainframes, las minicomputadoras, las PC y los teléfonos empezaron todos con sistemas de un solo programa y sin protección, y fueron incorporando multiprogramación, protección y memoria virtual a medida que su hardware lo permitió. Los microcontroladores actuales están en plena transición.
3. El hardware habilita; el sistema operativo aprovecha. Las interrupciones hicieron posible la multiprogramación; el temporizador, el tiempo compartido; el modo privilegiado y la unidad de gestión de memoria, la protección. Por eso el bloque 2 de este curso empieza por el hardware.
4. Las ideas sobreviven a los sistemas. Multics casi no se usó, pero sus ideas viven en Unix; Unix apenas se vende hoy, pero su diseño vive en Linux, Android, macOS e iOS. Estudiar los conceptos rinde más que estudiar un producto.

14. Fósiles en tu terminal

La historia no quedó en los libros: una terminal Linux está llena de restos de cada etapa. Algunos se pueden desenterrar con un comando.

$ tty                            # ¿a qué terminal estoy conectado?
/dev/pts/0

$ date -u -d @0                  # el instante cero de Unix
jue 01 ene 1970 00:00:00 UTC

$ date +%s                       # segundos transcurridos desde entonces
1791725527

$ who | wc -l                    # una tubería, como en 1973
1

$ ls /var/spool                  # colas de trabajos pendientes
cron  mail  rsyslog

El segundo y el tercer comando muestran una herencia directa de Unix: el kernel no guarda la fecha como día, mes y año, sino como la cantidad de segundos transcurridos desde el 1 de enero de 1970, un instante llamado epoch. Cualquier programa puede pedírsela:

#include <stdio.h>
#include <time.h>

int main(void)
{
    time_t ahora = time(NULL);   /* le pregunta la hora al kernel */

    printf("Segundos desde el 1 de enero de 1970: %ld\n", (long)ahora);
    printf("Equivale a unos %ld anios\n", (long)(ahora / (365.25 * 24 * 3600)));
    return 0;
}

$ gcc epoch.c -o epoch
$ ./epoch
Segundos desde el 1 de enero de 1970: 1791725527
Equivale a unos 56 anios

Otros fósiles están en el vocabulario que usarás a diario:

15. Qué nos dejó cada etapa

Esta tabla resume el tema y sirve de índice: indica en qué momento nació cada concepto y dónde lo estudiamos.

16. Resumen

• Las primeras computadoras no tenían sistema operativo: cada programador manejaba la máquina a mano, y esta pasaba la mayor parte del tiempo ociosa.
• Los sistemas por lotes introdujeron el monitor residente, antepasado del kernel, y obligaron al hardware a ofrecer protección, temporizador y modo privilegiado.
• La multiprogramación aprovechó las esperas de entrada y salida para ejecutar otros trabajos, y con ella nacieron la gestión de memoria y la planificación.
• El tiempo compartido dio a cada usuario la ilusión de una máquina propia y trajo las cuentas, los permisos y la interacción inmediata.
• Unix aportó un kernel pequeño escrito en C, la idea de que todo es un archivo, las tuberías y la shell como programa común. Linux, Android, macOS e iOS descienden de él.
• Las PC empezaron con sistemas sin protección porque su hardware no la permitía; la recuperaron con Linux y Windows NT cuando el procesador lo hizo posible.
• Los móviles sumaron la energía como recurso y el aislamiento entre aplicaciones; la nube reaplicó la virtualización de los años sesenta.
• Cada nueva clase de equipo repite la misma evolución, y las ideas duran más que los sistemas que las introdujeron.

17. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Ordena de memoria estas ideas según su aparición y explica qué problema resolvió cada una: tiempo compartido, monitor residente, contenedores, multiprogramación, interfaz gráfica.
2. Elige uno de los veinte sistemas del curso Historia de los Sistemas Operativos, léelo e identifica a cuál de las etapas de este tema pertenece y qué concepto aportó.
3. Cuando tengas Linux disponible, ejecuta los comandos de la sección 14 y calcula a mano, a partir de date +%s, cuántos días pasaron desde 1970.
4. Piensa en un dispositivo reciente (un reloj inteligente, un televisor, un automóvil): ¿en qué etapa de la evolución está su sistema operativo? ¿Tiene multitarea, protección entre aplicaciones, varios usuarios?