Sistemas Operativos

Módulo 1: Conceptos básicos

Autor: Remo Suppi Boldrito

Introducción

Un aspecto ineludible a considerar en la Ingeniería de Software, como disciplina que permite

al estudioso adoptar un enfoque sistemático y cuantificable al desarrollo, implantación y
mantenimiento de aplicaciones informáticas, es dónde y cómo se ejecutará esta. Para ello es
necesario no solo pensar en la eficiencia y el desempeño de las aplicaciones desarrolladas, sino que
cómo estas podrán, por ejemplo, ejecutarse sobre una arquitectura de múltiples núcleos o una red
de alta velocidad. El elemento unificador y habilitador de que toda la potencia de la tecnología pueda
ser utilizada por las aplicaciones es el sistema operativo que se transforma en la llave de acceso a las
prestaciones del hardware de los dispositivos electrónicos. Por lo mismo, para un estudioso de esta
área de conocimiento es de vital importancia conocer y entender qué prestaciones y servicios le
ofrece el sistema operativo, para luego poder desarrollar las aplicaciones que mejor se adapten y
aprovechen los recursos del dispositivo donde se ejecutan.

El concepto de Sistema Operativo (SO) en un dispositivo electrónico ha evolucionado

notablemente en las últimas décadas, transformándose en un elemento que se somete de forma
continua a grandes investigaciones e inversiones de la industria, las universidades y la comunidad
en general. Su objetivo no solo ha sido extender, adaptar y mejorar la interfaz hacia el usuario con
el fin de acercar este dispositivo a personas no expertas o sin conocimientos tecnológicos (es el caso
paradigmático, por ejemplo, de la evolución de los sistemas operativos para dispositivos móviles),
sino también en gestionar las complejas y potentes infraestructuras hardware que permiten, por
ejemplo, que un dispositivo móvil actual tenga igual potencia de procesamiento que un
supercomputador de la década de los 80 (ver en lecturas complementarias: “Apple iPad2 As Fast
As The Cray2 SuperComputer”).

Esta asignatura está organizada en tres módulos funcionales, en los cuales se verán
diferentes conceptos desde una breve historia de los SO y los aspectos de instalación y utilización.
Después se hará un repaso de las diferentes posibilidades de que existen hoy en día y de los concepto
avanzados de las estructuras internas, módulos que lo forman, cómo se ejecutan las aplicaciones
sobre ellos, cómo se virtualizan los sistemas operativos y cuáles son las tendencias más importantes
para los desarrolladores de aplicaciones. Todo el trabajo está encaminado para que el estudioso
pueda realizar diferentes experiencias y analizar cuáles son los conceptos necesarios, aplicarlos y
experimentar integrándolos con los aspectos prácticos para desarrollar las competencias propuestas
por el curso.

En el módulo uno se realizará una breve introducción a los primeros sistemas operativos
que han impulsado la utilización de dispositivos digitales hasta los actuales (Unix-Linux-Android,
Windows y MacOS-iOS, básicamente), mostrando los diferentes aspectos claves, estructuras e
interfaces de programación (API) que presentan y analizando con cierto detalle la estructura interna
de sus núcleos (kernel).

En el módulo dos se mostrarán las principales tendencias de los sistemas operativos y cómo
estos se han adaptado a diferentes entornos: industriales, sistemas críticos, electrónica de consumo,
oficina, servidores, etc. Asimismo, se presentarán cuáles son las tendencias actuales haciendo
experimentos con algunos sistemas operativos en cloud y virtualizados.

Finalmente, en el módulo tres se analizarán las diferentes tareas en la administración de los

sistemas operativos y se realizarán un conjunto de tareas y ejemplos sobre estos que permitan al
estudioso obtener las competencias sobre la administración y gestión de las tareas más habituales
sobre un sistema operativo, sobre todo en aquellos que son multiusuario (y multitarea).

Ideograma

Desde ‘50 Breve

historia

Sistemas Windows
Tipos Evolución
Operativos Mac OS X

Arquitectura
Contenido
1. ¿Qué es el Sistema Operativo (SO)? .................................................................................................. 5
2. Breve historia de los SO ...................................................................................................................... 5
3. Arquitectura de un Sistema Operativo (SO) ................................................................................... 27
3.1. Estructura monolítica ................................................................................................................ 31
3.2. Estructura jerárquica o por capas ............................................................................................ 33
3.3. Estructura de máquina virtual .................................................................................................. 35
3.4. Estructura por funciones........................................................................................................... 36
3.5. Micronúcleos, nanonúcleos y exonúcleos............................................................................... 37
4. Caso de uso.......................................................................................................................................... 39
4.1. Carga del sistema operativo e inicio (login).............................................................................. 39
5. Glosario ................................................................................................................................................ 46
6. Bibliografía ........................................................................................................................................... 47
1. ¿Qué es el Sistema Operativo (SO)?

Uno de los primeros conceptos que se deben definir es qué es un sistema operativo y para qué
sirve un sistema operativo. Existen muchas definiciones formales, pero se puede concluir que un
Sistema Operativo (SO) es un entorno software (programa) que se ejecuta en un dispositivo
electrónico, con o sin interacción con el usuario, para gestionar y administrar los recursos que
dispone dicho dispositivo.

El sistema operativo permite, por un lado, presentar un interfaz de interacción a los diferentes
usuarios aceptando órdenes y realizando el trabajo correspondiente. Esta visión se denomina ‘visión
centrada en el usuario’ y está orientada a diferentes tipos de usuario; por ejemplo, una interfaz
gráfica para los usuarios no expertos, una de texto para administradores o programadores, una de
librerías y programación para las aplicaciones que se ejecutarán sobre este sistema operativo, una
de entrada/salida para los diferentes elementos que se quieran interconectar con él, etc. Por otro a
lado, el sistema operativo, en su misión de gestión y administración de la infraestructura hardware,
se puede considerar, en una ‘visión como gestor de recursos’, como el artífice de extraer las mayores
prestaciones al hardware subyacente con la menor utilización de recursos y con el menor gasto de
energía (esta premisa es muy importante hoy en día, sobre todo en los dispositivos móviles).

Es importante aclarar que estas dos visiones son complementarias y los programadores de
sistemas operativos se deben esforzar para que en su conjunto presenten unas prestaciones óptimas
y eficientes, integradas bajo un mismo objetivo evitando, por ejemplo, que aspectos funcionales de
una vayan en detrimento de la otra o viceversa.

2. Breve historia de los SO

El concepto de sistema operativo ha ido evolucionando a través de tiempo para satisfacer un

conjunto de necesidades de los usuarios y acercar dispositivos electrónicos a un público que, sin
conocimientos prácticamente de tecnología, pueda utilizar y gestionar unos recursos extremamente
complejos, como los que disponen hoy en día cualquier teléfono móvil, ordenador o tableta, a un
bajo costo y con unas funcionalidades y prestaciones muy altas.

Se puede considerar que esta evolución ha permitido transformar la sociedad actual en la cual
las TIC (Tecnologías de la Información y la Comunicación) cumplen un papel predominante y las
personas ya no conciben la vida sin Internet o conexiones móviles, instantáneas y ubicuas. El futuro
depara un incremento de esta visión con la nueva ola de interacción e interconexión que llegará con
la implantación del paradigma llamado Internet de las Cosas (Internet of Things, IoT). Esta nueva
revolución está basada en la interconexión de objetos habituales a Internet, lo cual permitiría
gestionar extraer, procesar, aprender y tomar decisiones sobre grandes conjuntos de datos que
podrían ser desde los zapatos, a la ropa, alimentos, coches o electrodomésticos o cualquier artículo
o elemento que, conectado a Internet, pudiera ofrecer/recibir de forma fácil e inmediata
información y que sirviera, básicamente, en forma individual o agregada, para mejorar la calidad de
vida de las personas, reducir costos/mejorar eficiencias u ofrecer funcionalidades/información que
fueran objeto de negocio o de interés para las personas/empresas/instituciones.

En un principio, alrededor de 1940, los sistemas informáticos eran los sistemas electrónicos
digitales que estaban construidos por tecnólogos expertos (ingenieros electrónicos y físicos,
básicamente), pero que carecían de sistema operativo. Es decir, estos sistemas complejos y
específicos se diseñaban con las instrucciones que debían ejecutar y su control y datos eran
introducidos por un conjunto de interruptores que indicaban las operaciones de control. Este
procedimiento rudimentario, tedioso y arduo, llamado codificación en lenguaje máquina, permitía
ejecutar un programa y realizar una serie de instrucciones con sus correspondientes datos en un
hardware que utilizaba válvulas electrónicas como dispositivos electrónicos y donde todos los
componentes eran discretos y ocupaban un gran espacio físico, consumían gran cantidad de energía
y tenían un fiabilidad baja, ya que las válvulas eran de vida muy reducida. Esta es llamada la primera
generación de hardware.

Unos de los grandes avances en la historia de los computadores es la definición en 1945 de la

arquitectura Von Neumann (en nombre a su diseñador el matemático-físico John Von Neumann,
descrita en informe sobre la EDVAC). En este informe se presenta la arquitectura de un sistema
informático que incluye un procesador digital con diferentes partes modulares (unidad aritmético-
lógica, registros, unidad de control con un registro de instrucciones y un contador de programa)
que se complementaba con una memoria para almacenar datos e instrucciones y además un
almacenamiento masivo y mecanismos de entrada y salida. Este concepto ha evolucionado hasta
nuestros días, pero algunos conceptos y la esencia continúan vigentes en las arquitecturas modernas
más utilizadas actualmente. En la arquitectura Von Neumann, conocida como de ‘programa
almacenado’, el procesador repite un bucle infinito realizando un ciclo que repite a muy alta
velocidad los siguientes pasos: acceso a la memoria principal a leer una instrucción, decodificación
de la misma, acceso a la memoria principal a leer los datos si es pertinente (indicado por la
instrucción decodificada), ejecución de la instrucción y almacenamiento del resultado y vuelta a
comenzar con la siguiente instrucción y así indefinidamente. Esta arquitectura de ‘programa
almacenado’ representó toda un revolución sobre los anteriores sistemas informáticos controlados
por programas (el ordenador se diseñaba y construía con el programa que ejecutaría como, por
ejemplo, Colossus Mark II -1944- o Eniac -1946- ) (Goldstine & Goldstine, 1946).

La propuesta de esta arquitectura es una solución a los problemas que presentaban las
arquitecturas del momento, ya que al estar integrado el programa dentro de la computadora, una
actividad tan necesaria como cambiar el programa a ejecutar significaba reestructurar las conexiones
internas, las diferentes partes o, en algunos casos, rediseñar la propia máquina, motivo por el cual
solo se ‘reprogramaba’ cuando no había otra alternativa, siendo un proceso tedioso y complejo que
incluía una nueva definición de los módulos (y la electrónica) a partir de diagramas en papel, la
ingeniería correspondiente (interconexión de las partes y adecuación) y verificación de que todo lo
diseñado en el papel funcionaba. ¡Existen registros que tardaban tres semanas en reprogramarse y
poner un nuevo programa en funcionamiento de ENIAC!
 La arquitectura Von Neumann supuso un avance notable, ya que los programas se almacenaban
en memoria principal y luego solo se debían cambiar un conjunto de interruptores para seleccionar
uno u otro programa según la necesidad.

Imagen 1. Computadores Colossus Mark II y Eniac de programa integrado (1944 y 1946).

Fuente: Wikimedia (s.f.).

Esta evolución en la arquitectura y en la posibilidad de tener diferentes programas

almacenados intercambiables propició que los investigadores incluyeran un programa adicional (de
gestión), llamado monitor, que permitiera cambiar la ejecución de los programas almacenados y se
considera que este fue el precursor de los sistemas operativos actuales. La evolución de este monitor
despertó nuevas necesidades que hizo, ya a inicios de la década del 1950, que hubiera nuevos
problemas, para lo cual surgieron también nuevas soluciones.

La posibilidad de ejecutar un programa mediante una simple elección permitió que se

ampliara el número de usuarios potenciales (uno por vez) que utilizaba toda la máquina. A los
usuarios se les asignaba una cuota de tiempo (para facilitar la distribución) pero los problemas
surgían con la complejidad de introducir los datos y extraerlos del computador, que significaba casi
todo el tiempo asignado, quedando muy poco para la ejecución en la mayoría de los casos. A raíz
de esto se amplió el monitor, llamándose Monitor Residente, que incluía rutinas de entrada/salida
para que el programador las pudiera utilizar desde su programa y automatizar la E/S facilitándola y
dedicando la mayor parte de su tiempo a la ejecución (en términos actuales fue una API -Application
Programming Interface- de E/S equivalente a la BIOS -Basic Input/Output System- de un
ordenador moderno) y para muchos autores, como Peterson et al. (1994), Stalling (2004) y
Tanembaum y Woodhull (1996), este es el embrión de primer sistema operativo

El monitor residente evolucionó con gran aceptación por parte de los usuarios y gestores,
ya que optimizaba notablemente el tiempo de preparación entre usuarios y permitía fácilmente
cargar programas/datos a memoria utilizando como dispositivos de E/S cinta o de tarjetas
perforadas, ponerlos a ejecutar y salvar los resultados de la ejecución (generalmente, en una
impresora).
 Con la irrupción a mediados de la década del 50 de la segunda generación de computadores,
ya basada en electrónica de estado sólido (silicio), se pudo obtener más fiabilidad de los sistemas
informáticos, reducir su costo y tamaño y poder ofrecerlo a clientes no tecnólogos estableciendo
una separación entre quien construía la máquina y quien la utilizaba, generando una posibilidad de
negocio y, por lo tanto, un instrumento con el cual dejaba de ser prototipos de laboratorio y solo
para personas expertas. Esto propició que grandes empresas e instituciones gubernamentales se
sintieran interesadas, formando su personal y alquilando o comprando uno de estos computadores.
Uno de los problemas que se presentaban en ese momento era la eficiencia, ya que la carga/descarga
de programas era muy alta en relación a la ejecución y la mayor parte del tiempo el computador,
que tenían costos elevados, estaba ocioso.

Eso motivó a que las investigaciones se dirigieran a solucionar este problema y llevaron a la
empresa General Motors, en 1955, a diseñar un programa de administración para la arquitectura
IBM701, llamado GM-NAA-I/O1. Este fue considerado como el primer sistema operativo, aunque
otros consideran que el primero fue desarrollado y diseñado por el Massachusetts Institute of
Technology (MIT), llamado MIT's Tape Director Operating System (1954), que se ejecutaba en
un computador Univac-1103 (ver lecturas complementarias) y que cumplía objetivos similares2.

Para automatizar el trabajo y rentabilizar las compras de estos costosos computadores, los
primeros sistemas operativos trabajaban ‘por lotes’ (llamado, en inglés, procesamiento batch) para
ordenar todos los trabajos similares y reducir el tiempo que se requería en la preparación y ejecución
de los programas, es decir, si se debía compilar un programa se preparaban todos los trabajos de
compilación juntos y se aprovechaba a hacerlos todos de una tirada para no tener que cargar y
descargar el software del compilador desde la memoria y solo leer todos los datos de entrada (desde
tarjetas perforadas o desde cintas), generando la salida de todas las ejecuciones en el dispositivo
correspondiente (lo habitual era una impresora o también podían ser cintas). Ejemplos de estos
sistemas informáticos eran los IBM serie 7000, ya con transistores (que reemplazaron la serie 700
que eran de válvulas) que incluían como operativo el IBM-FMS (Fortran Monitor System) y Share-
OS (conocido como SOS y creado en 1959 como una mejora del GM-NAA-I/O)3.

En 1962, este sistema operativo fue discontinuado a favor de IBSYS (basado en sus
predecesores -FMS y Share- e incompatible con estos, por lo cual solo se vendía con las nuevas
unidades en 1960) y diseñado para aprovechar todas las funcionalidades de las nuevas (y muy caras)
IBM 7090-94. IBSYS estaba compuesto por un monitor residente básico que leía las tarjetas de
control existente entre las tarjetas de datos (que identificaba por el signo $ en la primera columna
de la tarjeta) y donde se especificaba cuál programa se debía ejecutar para la siguiente secuencia de
tarjetas de datos. Un aspecto importante que introdujo el 7090 fue que ya no era necesario utilizar
lectoras mecánicas de tarjetas (muy lentas), sino que estas previamente se volcaban a una cinta
(mucho más rápida) y luego el 7090 las leía/escribía en cintas, reduciendo notablemente el tiempo

1 Consultado en: http://www-03.ibm.com/ibm/history/exhibits/mainframe/mainframe_PP704.html

2 Consultado en: http://www.computerhistory.org/tdih/March/8/
3 Consultado en:

http://web.archive.org/web/20070928190200/http://www.piercefuller.com/library/share.html?id=share
de E/S (representando también un negocio para IBM que no solo vendía/alquilaba el computador,
sino varias lectoras adicionales de tarjetas/cintas para acelerar el trabajo previo de pasar las tarjetas
a cintas o pasar la salida de los programas de cinta a impresora). Este tipo de procesamiento se
conoció como E/S o procesamiento offline.

La industria aceptó con gran entusiasmo, en la década de 1960, la comercialización de los

circuitos integrados (muchos componentes encapsulados en el mismo chip y que se conoce como
la tercera generación de computadores), que redujo el tamaño de las memorias y la electrónica
necesaria. Esto produjo una división de las líneas de negocio: cómputo científico (para instituciones
gubernamentales y laboratorios de investigación) y negocio (para empresas). Esta dualidad generaba
costos elevados a los fabricantes y empresas e IBM lo solucionó desarrollando una familia de
computadores (míticos) llamados IBM/360 (basada todas en circuitos integrados), que eran
escalables en potencia y recursos (y precio) y que el cliente podía ir ampliando en función de sus
necesidades. La principal ventaja era que los programas se ejecutaban en todos los ordenadores de
la familia y permitían satisfacer las necesidades de cómputo científico y cómputo comercial con
unas prestaciones y precios aceptables. El sistema operativo que incluía era el OS/3604, que estaba
pensado para gestionar tanto las máquinas más pequeñas de la familia como las más grandes y
potentes e incluía una técnica que marcó el desarrollo de todo los sistemas operativos: la
multiprogramación.

La multiprogramación es un técnica (concepto que forma parte en esencia de todos los SO

modernos) que permite que cuando un programa en ejecución (llamado proceso y que incluye el
código ejecutable, sus instrucciones, datos y zonas de memoria, además de todas las estructuras de
datos del SO) debe realizar una E/S (por ejemplo, en aquel momento una lectura de cinta) suspende
el proceso en ejecución, salva su contexto y carga el contexto del siguiente trabajo a ejecutar que ya
está disponible en memoria principal. Cuando el proceso actual debe hacer una E/S salva su
contexto y carga el contexto del anterior y lo vuelve a ejecutar. Es decir, hay un intercambio de
tareas y las tareas que son suspendidas se volverán a ejecutar desde el punto donde fueron
suspendidas como si nada hubiera pasado. Esta técnica permitió salvar gran cantidad de tiempo en
la ejecución de las tareas, ya que permitía solapar la E/S de una tarea con el cómputo de la siguiente.

La multiprogramación implicaba una gestión muy controlada de la memoria, pues existían

múltiples tareas a ejecutar con sus datos y se tenía que evitar que una pudiera afectar la zona de otra,
por lo cual el hardware estaba diseñado para ofrecer estas protecciones. Una evolución de esta técnica
(incluida también por IBM en el OS/360 y para las máquinas más grandes de la familia) fue el Time
Sharing (tiempo compartido) para dar soporte a múltiples usuarios (sobre todo de la línea comercial),
que permitía a varios usuarios estar trabajando en un terminal en forma interactiva con la ‘sensación’
de tener todo el computador disponible para él, aunque en realidad este era compartido entre todos
ellos. Estos sistemas, que incluían la técnica de la multiprogramación, cuando una tarea llevaba un
cierto tiempo ejecutándose, se suspendía, guardándose el contexto y pasando a una tarea de otro

4 Consultado en: http://www-03.ibm.com/systems/z/os/zvse/about/history1960s.html

usuario, utilizando algoritmos de planificación para que el tiempo de utilización se distribuyeran
bajo diferentes criterios indicados por el administrador del sistema.

IBM desarrolló en esta década (1960) diferentes variantes del OS/360 que, junto con una
nueva línea de SO, llamado TimeSharing Operating System TSS/360, se adecuaba a las diferentes
máquinas y necesidades de negocio. Entre ellos se pueden mencionar, además del TSS/360, el
BOS/360 (Basic Operating System, pensado para las IBM360 pequeñas con 8 kB de memoria),
TOS/360 (Tape Operating System, para máquinas de por lo menos 16k bytes de memoria) y
finalmente DOS/360 (Disk Operating System), primero en utilizar la tecnología de discos
magnéticos para almacenar el propio sistema operativo y el código/datos de las tareas. El DOS/360
evolucionó al DOS/VS (1972) y fue el primero en incluir soporte de memoria virtual. Las técnicas
de memoria virtual permitían que una tarea se pudiera ejecutar sin estar totalmente su código y
datos ubicados en la memoria principal, sino en un dispositivo secundario (generalmente, un disco
llamado unidad de swap) y cargar el código y los datos que le eran necesarios en tiempo de ejecución.
Obviamente, esto necesitaba una memoria de gran tamaño y un soporte hardware importante para
permitir almacenar las tablas de páginas, forma en que se dividía la memoria, algo que ya incluían
las máquinas de la época5.

El OS/360 fue distribuido en diversas variantes como la versión MFT (Multiprogramming

with Fixed number of Tasks) o MVT (Multiprogramming with Variable number of Tasks) que
formaron parte de las técnicas de los sistemas operativos diseñados por IBM hasta la década del
1980. El OS/360 fue escrito, en principio, en lenguaje ensamblador y luego reescrito en BSL (Basic
Systems Language) derivado del lenguaje PL/I. Un aspecto interesante es que el OS/360 tiene
licencia de dominio público y puede ser obtenido y ejecutado en un emulador llamado Hercules,
que se ejecuta sobre diferentes sistemas operativos actuales6; por ejemplo, Linux. La siguiente
imagen muestra una IBM360-20, con los paneles frontales quitados de 32 kB de memoria y
procesador de 16 bits, utilizando como operativo uno denominado Disk Programming System
(DPS) y con lenguajes Report Program Generator (RPG) minimal PL/I y Basic Assembler, y una
IBM2560 MFCM (MultiFunction Card Machine):

5 Consultado en: http://www-03.ibm.com/systems/z/os/zvse/about/history1960s.html

6 Consultado en: http://www.hercules-390.org/
 Imagen 2. IBM360-20 –la más pequeña de la familia- e IBM2560 MFCM.

Fuente: Wikipedia (s.f.).

Otros sistemas operativos relevantes de esta década para ordenadores de la 3ª generación (todos
en base a circuitos integrados) fueron:

- Pick Operating System (1965): soportaba tiempo compartido y paginación bajo demanda,
técnica mediante la cual un programa se comenzaba a ejecutar sin tener nada cargado en
memoria principal e iba solicitando la carga del código y los datos que necesitaba a través
del soporte de memoria virtual, y el hardware correspondiente con el consiguiente ahorro de
memoria principal. Estaba diseñado específicamente para cómputo de
negocio/transacciones y existen algunas versiones evolucionadas que todavía se pueden
ejecutar en máquinas actuales (Sisk et al., 1985).

- Michigan Terminal System (MTS) (1967)7: que era un time-sharing computer operating system
desarrollado en la Universidad de Michingan para un IBM S/360-67, pero compatible con
diversos computadores de la época. Se mantuvo en funcionamiento y con soporte durante
más de 30 años (1967 a 1999).

- Incompatible Timesharing System (ITS) (1967)8: desarrollado por el MIT Artificial

Intelligence Laboratory dentro del proyecto MAC sobre una plataforma DEC PDP6-10
(conocido fabricante de hardware Digital Equipment Corporation a finales de los 60 y los
90) y conocido por sus revolucionarias ideas en cuanto a las técnicas utilizadas para gestionar
el tiempo compartido, las tareas y su distribución y utilización de los recursos. Era un
sistema operativo que permitía participar a personas externas al proyecto, llamados guest o
tourist, en su desarrollo y test a través de una incipiente red llamada ARPAnet, precursora
de lo que hoy es Internet. Se considera que este entorno software fue uno de los principales

7Consultado en: http://archive.michigan-terminal-system.org/

8Consultado en:
http://web.archive.org/web/20120226113808/http://www.avanthar.com/~healyzh/sysdoc/sysdoc.html
 precursores y aportó la definición e influencias en los que hoy conocemos como la Cultura
Hacker.

- WAITS (1967): acrónimo no oficial de West-coast Alternative to ITS. Fue una rama de
diseño derivada, aunque con grandes diferencias, del sistema operativo de DEC MOS
(Digital Equipment Corporation's Monitor Operating System). WAITS fue renombrado
posteriormente como TOPS-10 para la PDP-6/10 y utilizado por Stanford Artificial
Intelligence Laboratory (SAIL) desde los 60 hasta 1991. Los exalumnos de Stanford y
WAITS que trabajaron en Xerox PARC, empresa que ha realizado grandes aportes al
mundo de la informática, como la impresión láser, Ethernet, el ordenador personal, la
Graphical User Interface (GUI), tuvieron un papel importante en Xerox Star, Apple
Macintosh y Sun Microsystems, que han sido las empresas que han revolucionado el
mercado de las TIC al finales del siglo pasado.

- Multiplexed Information and Computing Service (Multics) (1969): fruto de un

proyecto iniciado en 1964 en Cambridge, Massachusetts. Ha sido uno de los sistemas
operativos más influyentes en los time-sharing operating system y que sirvió como base al
desarrollo de Unics, que es conocido hoy en día como Unix (Multics, 1965).

- UNICS (1969): durante el desarrollo de Multics por el MIT, AT&T Bell Labs, y General
Electric se introdujeron muchas innovaciones, pero también se generaron muchos
problemas complejos de resolver y que hacían peligrar la viabilidad del proyecto. Los
investigadores de Bell Labs, frustrados por el tamaño y complejidad que adquiría Multics,
dejaron el proyecto y un grupo de ellos, formado por Thompson, Ritchie, McIlroy y
Ossanna, tomó la decisión de continuar el trabajo iniciado pero a menor escala. En 1970
presentaron el proyecto UNICS (UNiplexed Information and Computing Service) como
contrapunto a Multics (Multiplexed Information and Computer Services) y que luego, en
1972, sería reescrito en lenguaje C y renombrado como Unix9.

Ya en la década de 1970, Unix empezó a trabajar bajo licencia abierta, lo cual generó una amplia
gama de versiones académicas, como la de BSD (University of California, Berkeley), o comerciales,
como Microsoft Xenix, IBM AIX y Sun Microsystems SunOS/Solaris. AT&T finalmente cerró
la licencia y desarrolló en 1983 una versión comercial que incluía el aporte realizado por la
comunidad y las universidades, llamada Unix System V Release 1, que es sobre el cual está basado
la mayoría de los SO Unix comerciales. Posteriormente, vendió sus derechos a la empresa Novell a
principios de los 90 y esta, a su vez, a la empresa SCO (Santa Cruz Operation) en 1995. La marca
Unix es una marca registrada por The Open Group que permite su utilización a los sistemas que
cumplen con las especificaciones de Single Unix Specification (SUS). En general, Unix se ha
caracterizado por su modularidad e independencia de dispositivos (llamada filosofía Unix), donde
el sistema operativo provee un conjunto de llamadas (API), comandos y herramientas simples para

9 Consultado en: http://www.cs.dartmouth.edu/~doug/reader.pdf

gestionar los procesos, un sistema de archivos unificado y un subsistema de comunicaciones y de
E/S junto con la potencia de procesamiento a través de archivos de script (código ASCII e
interpretado), los cuales permiten generar nuevos comandos u órdenes complejas a través de los
existentes. Además de este diseño modular, Unix se distingue por su portabilidad a otras
arquitecturas y se conoce como el primer sistema operativo portable, ya que al estar en su gran
mayoría escrito en el lenguaje de programación C su adaptación a nuevas arquitecturas es muy
simple. Uno de los exponentes actuales, siguiendo estas premisas, pero reescrito de nuevo y sin
código del anterior para evitar las protecciones legales, es Linux y sobre el cual se hablará con
posterioridad, ya que es el sistema operativo bajo licencia abierta GNU más utilizado en la actualidad
en servidores, grandes sistemas de cómputo, como clústeres, y sistemas de cómputo en la nube
(clouds)10.

Sobre las versiones representativas de este sistema operativo se pueden mencionar Unix
Version 6 (1975), la primera versión de Unix liberada por Bell Labs y que se ejecutaba sobre una
DEC PDP-11, y la Unix Version 7 en 1978/9. y se tiene constancia que ha estado en
funcionamiento hasta 1985. La Version 5 Unix solo fue licenciada por AT&T a instituciones
académicas y la Version 6 destinada a empresas comerciales (con un costo de U$S 20.000).

- Unix System III (1982): junto a las diferentes versiones basadas en versiones anteriores y
desarrolladas por empresas o universidades, generaba mucha confusión en el mercado y es
por ello que AT&T en 1983 presentó Unix System V Release 1 con el compromiso que
sería compatible con versiones futuras y que incluiría tanto sus propios desarrollos como
otros realizados en universidades y centros de investigación. Esta versión (ya con licencia
cerrada) ha sido la que ha dado lugar a otros Unix como HP-UX, AIX, Solaris, Irix, etc.
- RT-11 (Real Time Operating System) (1970): fue uno de los primeros sistemas
operativos con especificaciones para trabajar en tiempo real y soportar procesos
(generalmente, industriales) con restricciones temporales (usualmente, tiempo máximo de
respuesta y de ejecución de tareas que deben ser atendidas en tiempo real) desarrollado para
una arquitectura DEC PDP-11 de 16 bits. Este sistema (hw/sw) fue utilizado ampliamente
en el control de procesos industriales para la adquisición de información y control de
procesos en tiempo real11.
- Cray Operating System (COS) (1976): fue el sistema operativo desarrollado por la
empresa Cray para sus superordenadores, los más potentes de su época, llamados Cray-1, y
su sucesor, Cray X-MP. Esto incluía todas las técnicas y avances en sistemas operativos de
su época, pero gestionaban grandes cantidades de procesos en diferentes procesadores y en
memoria compartida. Incluía, además, el Cray Assembly Language (CAL), Cray FORTRAN
(CFT) y Pascal como parte del sistema operativo12.

10 Consultado en: http://www.cs.dartmouth.edu/~doug/reader.pdf

11 Consultado en: http://www.skrenta.com/pdpbook.txt
12 Consultado en: http://bitsavers.trailing-edge.com/pdf/cray/COS/T-0103C-CRAY_1_Computer_System-

Operating_System_COS_Workbook-Training-September_1981.OCR.pdf
 - FLEX (1976): fue un single-tasking operating system desarrollado por Technical Systems
Consultants (TSC) para un procesador Motorola 6800 y que se ejecutaba desde una unidad
de disco flexible de 8 pulgadas, pero también disponía una versión en discos flexibles de
5,25 pulgadas llamada mini-Flex. La interacción con el usuario era en modo texto, pero
algunos fabricantes lo adaptaron para dispositivos gráficos y ratón. No obstante, su mayor
innovación es que funcionaba desde un disco flexible que utilizaba sectores de 256 bytes con
una estructura de directorios simple (a través de unas tablas) incluyendo soporte para la
programación en BASIC13.
- Apple DOS (1978): fue una gama de sistemas operativos para la familia de ordenadores
Apple II y que se llamaron DOS 3.1- 3.2-3.3 (última versión en 1983). En 2013, 35 años
después de la aparición de Apple II, el código de Apple DOS fue liberado al Computer
History Museum por su creador Paul Laughton y se encuentra disponible en su página web14.
- Atari DOS (1979): fue el sistema operativo (en disco flexible también) utilizado por la
familia de ordenadores de 8 bits Atari (llamados home computers o game computers),
fabricados por la empresa del mismo nombre. Las extensiones del sistema operativo eran
cargadas en memoria junto con un controlador de disco que permitía gestionar los archivos
almacenados en este. El gestor de disco era la extensión más importante del sistema
operativo y que en la versión de 2.0 se transformó en el File Management System (FMS)
que era una implementación de sistema de archivos en memoria cargado desde el disco
flexible15.

A partir de la década de 1980 se popularizaron las máquinas de uso personal (conocidsa como
4ª generación de computadores) con la irrupción en el mercado de los circuitos integrados de gran
escala (LSI), con chips de miles de transistores y el surgimiento del microprocesador, similares a lo
conocemos hoy en día, que favorecieron la construcción de estos computadores para uso personal.
La evolución a pantalla gráficas, una capacidad de cómputo apreciable e interactivo, propició una
floreciente industria que producía ordenadores para un público no tecnólogo y más orientado a la
electrónica de consumo que al negocio o el cómputo científico. Los mayores actores al inicio de
esta década fueron Apple con su hardware Macintosh y el sistema operativo MacOS, IBM+Microsoft
con el PC+MSDOS y Unix (aunque este último más orientado hacia estaciones de trabajo –un poco
más potentes- que a computadores, personales pero rápidamente haría el paso para ejecutarse
también en estos).

- MS-DOS (Microsoft Disk Operating System) (1981): fue un desarrollo de Microsoft

para máquinas basadas en el microprocesador x86 desarrolladas por IBM PC, pero que
rápidamente se extendió a otros ordenadores llamados PC compatible y que no eran
fabricados por IBM (desde 1981 hasta mediados de los 90) y que fue reemplazado por
sistemas operativos que incluyeran una interfaz gráfica, como ha sido toda la familia de
sistemas operativos Windows. El diseño de MSDOS proviene de la adquisición de los

13 Consultado en: referencia: http://www.flexusergroup.com/flexusergroup/fug3.htm

14 Consultado en: http://www.computerhistory.org/atchm/apple-ii-dos-source-code/
15 Consultado en: http://www.atariarchives.org/creativeatari/Atari_DOS.php
 derechos del sistema operativo 86-DOS de la empresa Seattle Computer Products, al cual
se le incluyeron modificaciones para cumplir con las exigencias de IBM y la cual
comercializaba este sistema operativo como PCDOS 1.0 para utilizar en su familia de PC.
Los desarrollos de MS-DOS y PCDOS fueron proyectos que evolucionaban inicialmente
en forma paralela pero rápidamente tomaron caminos separados y MS-DOS desarrolló 8
versiones (finalizando la última en el año 2000). MS-DOS se ejecutaba sobre procesadores
Intel 8086/286/386 y podía ejecutarse desde un disco flexible o desde un disco duro. Este
dispositivo fue rápidamente fue adoptado por el mercado por su reducción en los precios,
el incremento de la capacidad y la posibilidad de tener un conjunto de programas instalados
cosa que no era posible sobre el disco flexible a no ser que se trabajara con 2 disqueteras
intercambiando los discos16.
- SunOS (1982): versión de Unix operating system desarrollada por la empresa Sun
Microsystems (una de los grandes fabricantes de estaciones de trabajo y microprocesadores,
adquirida en 2010 la compañía Oracle) para sus estaciones de trabajo y servidores. Hasta la
SunOS versión 4 el desarrollo se basaba en BSD, pero a partir de SunOS 5.0 la compañía
decidió cambiar el diseño y basarlo sobre UNIX System V Release 4 y comercializarlo con
el nombre de Solaris (en 2015 en la versión 11) para hacer frente a la competencia
soportando el estándar de Unix System V predominante en el mercado17.
- GNU (1983): es un proyecto que se inicia con el objetivo de generar un Unix-like Computer
Operating System y herramientas basadas en la premisa del Open Source (código abierto y
libre). GNU es una abreviatura recursiva de GNU's Not Unix!, donde el software desarrollado
bajo este proyecto no contiene código Unix y el proyecto está gestionado por la Free
Software Foundation (FSF). Uno de los aspectos interesantes del proyecto es que núcleos
de sistemas operativos que no forma parte del proyecto GNU (el más famoso es el núcleo
de Linux) pueden utilizar todas las herramientas desarrolladas bajo el proyecto dando lugar
a distribuciones llamadas comúnmente Linux, pero que en realidad deben denominarse
GNU/Linux. Mucho software ha sido escrito desde cero para evitar cuestiones de propiedad
y patentes, pero mucho otro software, ya bajo la premisa de open Source, ha sido incluido para
formar parte de proyecto como, por ejemplo, TeX (sistema de edición y producción de
documentos), sistema gráfico Xwindows, el micronúcleo del sistema operativo Mach -que
forma parte del GNU Mach- y es la parte principal del núcleo del sistema operativo oficial
del proyecto GNU llamado GNU Hurd18.
- MacOS (1984) es el sistema operativo introducido por Apple Computer Inc. Para sus
máquinas Macintosh personal computer que revoluciona el mercado de los ordenadores
personales con su interfaz gráfica interactiva y el concepto de ventanas y escritorio de
usuario. Esta versión de sistema operativo fue parcialmente basada sobre el Lisa OS
desarrollado por Apple para el ordenador Lisa en 1983. Como parte de un acuerdo de
colaboración (a través de la compra de acciones) por parte de Xerox PARC, MacOS integró

16 Consultado en: http://www.computerhistory.org/atchm/microsoft-ms-dos-early-source-code/

17 Consultado en:
https://web.archive.org/web/20080619190941/http://www.ocf.berkeley.edu/solaris/versions/solaris/8.html
18 Consultado en: https://www.gnu.org/home.en.htm
 conceptos e innovaciones desarrolladas por esta última empresa, generando un sistema
operativo y un hardware con muy altas prestaciones e innovador para su época. En el 2000
Apple presentó un nuevo sistema operativo de fuente abierto, llamado Darwin, que incluye
toda la evolución y experiencia de Apple en sistemas operativos así como código derivado
de NeXTSTEP, BSD y otros proyectos open source. Darwin forma parte del núcleo de los
sistemas operativos OS X y iOS, es compatible con las normas Posix y desde la versión
10.5.8, llamada Leopard, es compatible con la Single UNIX Specification version 3 (SUSv3).
MacOS ha evolucionado a la versión actual (octubre del 2014) que se llama OS X Yosemite
(versión 10.10) y da soporte a los ordenadores (de escritorio y servidores) Macintosh19.

Darwin ha continuado su camino como desarrollo abierto a través de diversos proyectos, como
OpenDarwin (liderado por Apple) y cerrado en 2006, o PureDarwin (sucesor de OpenDarwin a
partir de 2007) (http://www.puredarwin.org/). Para evitar problemas de licencias abiertas (open
source), Apple mantiene un sitio web (http://www.opensource.apple.com/) donde incluye todo el
código de este tipo e incluido en las diferentes versiones de sus sistemas operativos.

Un emulador de MacOS 7 se puede ejecutar en un navegador desde

https://jamesfriend.com.au/pce-js/ y que fue escrito por James Friend (ver imagen a
continuación).

Imagen 3. Emulador MacOS 7.

Fuente: Friend, J. (s.f.).

- Windows 1.0 (1985) es un interfaz gráfica desarrollada por Microsoft y que se ejecutaba
bajo MSDOS. Este desarrollo es fruto de los trabajos conjuntos entre Microsoft (Bill Gates)

19 Consultado en: http://www.apple.com/osx/

 y Apple Computer (Steve Jobs) sobre aspectos del MacOS (y los cuales acabaron en litigio
posteriormente por cuestiones de derechos), pero se considera que es el resultado producto
de la implicación de Microsoft en el desarrollo de los aspectos gráficos del MacOS y
Macintosh. Es interesante analizar un emulador (que se ejecuta sobre un navegador) de esta
interfaz más MSDOS en http://jsmachines.net/demos/pc/cga-win101/xt-cga-win101.xml
y escrito por Jeff Par, o una emulación de un PC/XT con Windows 3.0 escrito por James
Friend https://jamesfriend.com.au/pce-js/ibmpc-win/

Imagen 4. Windows 1.0 y Windows 3.0.

Fuente: Par, J. (s.f.).

- HP-UX (Hewlett-Packard UniX) (1984): es el desarrollo del Unix de la empresa Hewlett-

Packard basado en UNIX System V (aunque los primeros diseños fueron sobre System III).
La versión actual (11i v3 Update14 -2015- ) soporta todo el hardware producido por el
fabricante y procesadores (arquitecturas PA-RISC, Intel Itanium-Xeon) o tecnologías como
Ethernet de 10Gigabits20.
- MINIX (derivado de mini-Unix, 1987) es un Unix-like computer operating system basado
en una arquitectura de microkernel. Las primeras versiones fueron desarrolladas por el
profesor Andrew S. Tanenbaum para objetivos académicos y la enseñanza de sistemas
operativos para mostrar cómo se estructuraba y funcionaba internamente un sistema tipo
Unix a nivel de código fuente, pero sin tener las restricciones de las licencias de Unix V7.
Este sistema operativo (en su versión actual MINIX3 y descargable desde
http://www.minix3.org/) fue desarrollado como software de código abierto (open source) y se
encuentra disponible para su estudio y forma parte del libro de sistemas operativos
publicado por su desarrollador. Una de las grandes ventajas de Minix es que fue escrito
desde cero, pero una década después de Unix, por lo cual tiene un conjunto de ventajas
propias de la época en la cual se desarrolló: estructura totalmente modular, sistema de
archivos no integrado en el SO, sino como programa de usuario; arquitectura fácil de
entender (comprensible en aras de la eficiencia), muy comentado para facilitar su
entendimiento, adopción de estándar Posix, escrito en C y sin requerimientos especiales

20 Consultado en: http://www.hp.com/go/hpux/

 para su ejecución (se puede ejecutar desde los discos flexibles incluidos en el libro del autor
y en las versiones actuales desde una máquina virtualizada o un usb). El crecimiento de
Minix y su apertura a la comunidad propiciaron que un estudiante finlandés, llamado Linus
Torvalds, decidiera escribir un clon de Minix para incluir un conjunto de prestaciones que
Minix no aceptaba (por su objetivo académico) y que fuera apto para máquinas en
producción. El autor llamó a este nuevo desarrollo con el nombre de Linux21.
- Windows 3.0 (1990) fue un sistema operativo con entorno gráfico, considerada la primera
versión de Windows para competir con Apple Macintosh, Commodore Amiga y que
posteriormente evolucionó a Windows 3.1. Todo se inició con un experimento
independiente de los desarrolladores de la compañía para crear un Windows en modo
protegido (modo de trabajo del procesador que permitía superar las restricciones de acceso
a los recursos –básicamente memoria- bajo las cuales se ejecutaba MSDOS) y cuando el
prototipo fue mostrado a los directivos rápidamente se transformó en un proyecto de la
empresa. Este usaba las diferentes parte de MSDOS pero al trabajar en el modo protegido
de procesador permitía a las aplicaciones Windows utilizar más memoria (que bajo MSDOS)
y por lo cual rápidamente se popularizó aprovechando las ventajas de los procesadores Intel
8086/8088 hasta 80286 y 80386, pudiéndose ejecutar en cualquiera de los modos que
presentaban estos22.
- The Linux kernel (1991) es un Unix-like computer operating system kernel ampliamente
utilizado bajo diferente distribuciones, conocidas como Linux distros y que han cambiado
radicalmente el entorno de la TIC desde los dispositivos móviles, pasando por los
ordenadores personales, servidores o máquinas de supercomputación (ver
http://www.top500.org/statistics/treemaps/ que muestra la influencia de Linux en los 500
ordenadores más potentes del mundo). Un ejemplo de ello lo podemos encontrar hoy en
día en Android, que es el sistema operativo más utilizado, el cual deriva de Linux y se
encuentra sobre la mayoría de las tabletas y teléfonos inteligentes. Como se mencionó
anteriormente, es un desarrollo de Linus Torvalds, bajo la premisa de open-source, que
ampliamente fue adoptado por la comunidad internacional y ha seguido con su desarrollo y
evolución (coordinada aún por Tovalds). Se estima más de 10.000 programadores han
contribuido al desarrollo del núcleo y que hoy está presente en todo tipo de máquinas, desde
supercomputadores a electrodomésticos. Su diseño ha evolucionado y su núcleo en la
actualidad es símbolo de estabilidad, eficiencia, prestaciones y seguridad y que ha permitido
competir con los grandes proveedores y cambiar la historia de la informática en todos los
niveles presentando alternativas a los modelos de negocio de software23.

En la siguiente figura se puede observar una captura de pantalla de Debian 8 (escritorio y

lanzador de aplicaciones) y una parte de las ramas y versiones de esta misma distribución. Debian
es una de las distribuciones más estables y de referencia de Linux y, como se puede observar en la

21 Consultado en: http://www.minix3.org/

22 Consultado en: http://windows.microsoft.com/en-us/windows/history#T1=era0
23 Consultado en: https://www.kernel.org/
figura, el interés en la comunidad y la implicación en el desarrollo y adaptación de este sistema
operativo en esta distribución (y en todas). La imagen completa se puede consultar en
https://commons.wikimedia.org/wiki/File:Linux_Distribution_Timeline.svg para todas las
distribuciones de Linux.

Imagen 5. Línea de tiempo (parcial).

Fuente: http://futurist.se/gldt/

No se puede dejar de mencionar las evoluciones del sistema operativo Windows a partir de
la versión Windows 95 (versión para usuarios domésticos), en la cual se integraron todas las
funcionalidades de Windows 3.1 y MSDOS agregando una nueva interfaz de usuario, pasando de
una arquitectura de 16 bits multitarea a una arquitectura de 32 bits multitarea pero con apropiación.
Sucesivas evoluciones de esta versión fueron Windows 98 y Windows ME que incluían los avances
de las arquitecturas modernas de procesadores y la posibilidad de gestionar mayor cantidad de
memoria. Un proyecto desarrollado en paralelo al Windows 95 fue el diseño de Windows NT
(1993) como sistemas operativo multitarea con apropiación y multiusuario con interfaz gráfica para
monoprocesadores y sistemas multiprocesadores. Es de destacar la Windows NT versión 4 (1996)
que incluía la interfaz de Windows 95 sobre la familia de operativos NT. Windows XP (2001) es
otra evolución de las versiones de Windows NT, pero basado sobre el núcleo de este y no sobre la
línea de Windows95, con el objetivo de unir las dos líneas de núcleos y de negocio. Los esfuerzos
en XP estaban puestos en mejorar la seguridad, escalabilidad y eficiencia de los sistemas Windows
transformándose en un referente para la época. Sucesivas evoluciones de XP han sido Vista (2006),
7 (2009), 8 (2012), 10 (2015), acompañados por versiones de servidores Windows Server (2003,
2008, 2012)24.

Microsoft, a partir de Windows XP, desarrolló una estrategia para los sistemas operativos
diferenciados en la misma versión para usuarios (Home, Professional, Media Center, Tablet
Edition) y que ha seguido manteniendo en las versiones posteriores para adaptar el mismo sistema
operativo a diferentes segmentos del mercado teniendo en cuenta el hardware necesario para
ejecutarse y adecuando el precio (si bien la estructura y núcleo continúan siendo los mismos,
incluyen más o menos utilidades/herramientas/módulos/prestaciones). Por ejemplo, para
Windows8 encontramos las siguientes versiones: Single Language (básico o starter), para países
emergentes con una capacidades muy reducidas; Core, versión estándar para usuario doméstico;
Pro, para pequeñas empresas; Pro WMC, versión Pro pero con el Media Center; Enterprise, con
características específicas para empresas; RT, para dispositivos con arquitectura ARM (RISC
Technology) para tabletas y teléfonos. También se dispone una edición llamada N para países de la
Comunidad Europea, que no incluye el Windows Media Player a raíz de los litigios por monopolio
a los que ha tenido que enfrentarse la empresa en estos países.

24 Consultado en: http://windows.microsoft.com/en-us/windows/history#T1=era4

Imagen 6. Imagen parcial de la pantalla de inicio y del escritorio de Windows 8.1.

Fuente: Windows8.1® ejecutado en la máquina del autor.

En la siguiente figura se puede observar la línea de tiempo de Windows.

8.1 W10

Imagen 7. Línea de tiempo en el desarrollo de Windows.

Fuente: Wikipedia (s.f.).

El sistema operativo para dispositivos móviles ha tenido un gran desarrollo en la última

década debido a la transformación que ha experimentado el mercado y donde la conectividad y los
teléfonos inteligentes (smartphones) se han transformado en electrónica de consumo. Entre los
principales sistemas operativos podemos destacar:

- Palm OS (1996): también conocido como Garnet OS, es un sistema operativo para los
primeros sistemas móviles desarrollado por Palm, Inc., para los dispositivos de agenda y
asistente personal (PDA, personal digital assistants). Este fabricante fue uno de los primeros
en introducir en una PDA (que ya existían en aquel momento pero con teclado y más similar
a una calculadora que a un dispositivo gráfico) una pantalla táctil con una interfaz gráfica.
El dispositivo incluía una serie de aplicaciones como agenda, contactos, calendario,
traductor, conversores, notas, etc., que permitía organizar la información personal en forma
fácil y sencilla. Después de diversas compras de empresas y litigios PalmOS se ha
transformado en WebOS25.
- WebOS (2009): también conocido como LG WebOS, Open WebOS, HP WebOS o Palm
WebOS, es una evolución de PalmOS y fue reescrito utilizando un núcleo de Linux para
hacer frentes a diferentes necesidades del mercado de consumo liderado por dispositivos
inteligentes (móviles o no), como televisores, impresoras, tabletas o relojes. Este SO fue
inicialmente desarrollado por Palm (para sus PDA) y, cuando la empresa fue comprada por

25 Consultado en: https://www.palmsource.com/palmos/

 Hewlett-Packard, se permitió la apertura del código, denominándolo Open WebOS, el cual
se encuentra disponible en la plataforma. El sistema operativo y la tecnología fue más tarde
vendido a LG Electronics, empresa que ha continuado una rama del desarrollo por su parte
y se incluye en los dispositivos Smart TV/Watches de la compañía26.
- iOS (2007): es el sistema operativo para móviles desarrollado por Apple Inc. para toda su
gama de dispositivos iPhone, iPad, iPod iWatch y basado en Darwin (versión del SO basado
en un microkernel y FreeBSD). Originalmente fue desarrollado para el iPhone, pero
rápidamente formó parte del resto de dispositivos móviles de la empresa, incluidos algunos
dispositivos fijos como Apple TV. Una de las grandes líneas de negocio que abrió la empresa
vinculada a estos dispositivos/operativos fue un repositorio común de aplicaciones (Apple
Store), la cual es la única forma de acceder a las aplicaciones, instalarlas o actualizar el
sistema operativo y se estima que desde el primer iPhone (2007) hasta enero de 2015 se han
vendido cerca de 1000 millones de dispositivos con iOS. Su gran calidad en los gráficos y
animaciones, la utilización de pantallas de muy alta resolución con soporte multipunto y
gestos múltiples, cámaras múltiples y de alta resolución, potencia de procesamiento,
simplicidad y facilidad de uso han llevado a estos dispositivos a ser un elemento deseado
por muchos usuarios y transformarse en un artículo de éxito en todas sus versiones y a veces
utilizado como elemento de distinción social. A continuación se puede observar unas
capturas de pantallas de iOS 7 y iOS827.

Imagen 8. Capturas de pantalla de iOS7/iO8®.

Fuente: Sistemas operativo iOS® ejecutados en dispositivos del autor.

26 Consultado en: https://www.openwebosproject.org/

27 Consultado en: http://www.apple.com/ios/
 - Android (2008) es un sistema operativo basado en el núcleo de Linux y en la actualidad
desarrollado por Google. Se encuentra instalado en multitud de dispositivos móviles o fijos
como teléfonos, televisores, relojes, autos o aviones. En forma similar a iOS, soporta
pantallas táctiles multipunto con gestos múltiples que se acceden de forma directa con
desplazamiento de los dedos o escrituras sobre un teclado virtual. Las estadísticas muestran
que es el sistema operativo más instalado y utilizado de la historia y las aplicaciones
desarrolladas superan en más de los dos tercios de mercado las desarrolladas para otros
dispositivos. El código fuente es abierto (open source) bajo la licencia del mismo tipo de
Google, pero en algunos dispositivos se incluye software propietario y se ha transformado en
sistema operativo más popular debido a su modularidad y facilidad de integración con
nuevos dispositivos de alta tecnología y bajo costo. El nombre de Android deriva de la
novela de P. Dick, Androids Dream of Electric Sheep, (basada en la película Blade Runner), donde
aparecen como protagonistas los androides replicantes del modelo Nexus-6 (nombre
utilizado por Google para su smartphone también). Las diferentes versiones de Android se
identifican por el nombre de diferentes postres o dulces (en inglés) y por orden alfabético:
Apple Pie (1.0), Banana Bread (1.1), Cupcake (1.5), Donut (1.6), Eclair (2.0-1), Froyo (2.2),
Gingerbread (2.3), Honeycomb (3.0-2), Ice Cream Sandwich (4.0), Jelly Bean (4.1-3), KitKat
(4.4), Lollipop (5.0-1), Marshmallow (6.0) (esta última todavía no disponible)28.

Las pantallas que se muestran a continuación son de un teléfono móvil y la versión 4.4 (KitKat,
nombre de una famosa chocolatina de una empresa multinacional).

Imagen 9. Capturas de pantalla de Android 4.4.

28 Consultado en: https://www.android.com/

 Fuente: Sistemas operativo Android ejecutado en dispositivo del autor.

- ChromeOS (2011): es un sistema operativo basado sobre el núcleo de Linux y diseñado

con el objetivo de soportar aplicaciones web teniendo como idea principal (y es lo que fue
en un principio) un cliente web para máquinas con recursos muy escasos y conectada a
Internet. Este sistema operativo es desarrollado por Google y construido sobre la base de
un proyecto de licencia abierta llamado Chromiun OS que, a diferencia de ChromeOS,
puede ser descargado y compilado en forma abierta. ChromeOS dispone de muy pocas
aplicaciones nativas, pero paulatinamente se han ido creando aplicaciones empaquetadas
que puede trabajar sin conexión. Su desarrollador ha anunciado para las nuevas versiones la
posibilidad de ejecutar aplicaciones Android en forma nativa para fomentar su uso y
reutilizar el gran mercado de aplicaciones de este último. La siguiente imagen muestra una
captura de la pantalla principal y es el sistema operativo (para arquitecturas x86) se puede
descargar29.

Imagen 10. Capturas de pantalla de ChromeOS®.

Fuente: Sistemas operativo ChromeOS® ejecutado en dispositivo virtualizado por el autor.

Conclusiones

En este apartado se han visto una breve reseña sobre la historia de los sistemas operativos
y se han descrito las principales aportaciones en el tiempo que han realizado. Es importante destacar
que este solo es un resumen no es exhaustivo, que no contiene todos los sistemas y que el lector
puede encontrar que faltan algunas aportaciones que considere importantes o algunos desarrollos
que no se han tenido en cuenta. Para ello se sugiere consultar a la bibliografía a final del módulo y
una línea de tiempo muy completa. Se puede obtener desde
https://en.wikipedia.org/wiki/Timeline_of_operating_systems.

29 Consultado en: http://getchrome.eu/download

3. Arquitectura de un Sistema Operativo (SO)
Antes de introducir las principales arquitecturas de los sistemas operativos, se deben definir una
serie de conceptos (algunos de ellos ya han sido mencionados anteriormente), ya que son necesarios
luego para describir cómo han afectado el diseño de los sistemas operativos (Tanenbaum, 2009)
(Silberschatz, 2000) (Nutt, 2006) (Carretero, 2010) (Suppi & Marzo, 2011).

1. Procesos e hilos (threads): el proceso es uno de los conceptos fundamentales en sistemas

operativos y se puede decir que un proceso es la unidad de trabajo o tarea que gestiona y
controla el sistema operativo, incluso la propia actividad que debe desarrollar el sistema
operativo se descompone en tareas llamadas procesos, y que representa un concepto
dinámico. Estos procesos constan del código ejecutable de la tarea, un conjunto de registros
(contador de programa, apuntador de pila y otros registros), estado, tablas y estructuras de
datos, zonas de memoria ocupada y toda la información que necesita el SO para ejecutar
este código, es decir, un proceso es un programa en ejecución y de ahí su condición
dinámica, ya que, a diferencia del ejecutable que se guarda en disco y que siempre es el
mismo, esta información cambia mientras avanza la ejecución (se modifican las tablas, las
zonas de memoria, los datos, los registros, etc.). Asimismo, a estos procesos se puede
suspender su ejecución, reiniciar, parar o bloquear según lo indique el sistema operativo
para lograr que todos los procesos existentes tengan acceso a los todos recursos en forma
coherente y compartida.
Un hilo (thread) es un concepto que ha evolucionado dentro del concepto de proceso
para poder realizar tareas en forma concurrente (si hay más de un núcleo del procesador) o
que dentro de mismo espacio de direcciones se puedan ejecutar diferentes actividades en
forma rotatoria para darle más “agilidad” a la tarea que desempeñan. Por ejemplo, cada hilo
puede ser una función que atiende una parte de una interfaz gráfica que cuando el tiempo
de CPU se asigna al proceso que los contiene todos los hilos se irán ejecutando en forma
circular dentro del tiempo asignado al proceso, dando la sensación que la interfaz responde
a todas sus partes ya que las funciones que la atienden se ejecutan varias veces durante el
tiempo asignado al proceso. En el caso de tener el procesador 2 (o más) núcleos, cada uno
de ellos podrá ejecutar un hilos diferentes realizando las tareas asignadas en forma
simultánea o en paralelo. Desde el punto del sistema operativo y la gestión de recursos el
trabajar con hilos es mucho más ventajoso, ya que es un elemento más fácil/rápido de
crear/suspender/terminar y más dinámicos que los procesos (en los cuales es necesario por
ejemplo para cambiar de un proceso a otro salvar el contexto de uno, cargar el del otro
teniendo en cuenta que cada uno tiene un espacio de direcciones separado). En el caso de
un hilo, dado que comparten el mismo espacio de direcciones, se puede cambiar fácilmente
y rápidamente de uno a otro y compartir datos entre ellos de una forma muy fácil. Las
capturas a continuación muestran la actividad de los hilos (threads) en un sistema operativo
Linux (mediante la aplicación xosview) sobre una arquitectura Intel de 64bits con 4 núcleos
(representados como CPU0-CPU3) y donde se puede ver en una línea de tiempo la
simultaneidad en la ejecución de los procesos y los threads asociados y la carga instantánea
de ese núcleo.
 Imagen 11. Capturas de pantalla de la aplicación xosview sobre Debian8.

Fuente: ejecutado en dispositivo virtualizado por el autor.

2. Multiprogramación: es la técnica que permite tener más de un proceso en memoria

principal y cuando un proceso no puede continuar su ejecución (por ejemplo porque debe
hacer una E/S) se guarda su estado, se carga el estado del siguiente proceso en memoria y
se pone a ejecutar. Cuando el segundo proceso debe realizar una E/S se guarda su estado,
se suspende, se recupera el estado del primero y se continúa con su ejecución. Esto permite
solapar la ejecución en CPU (cómputo) con la E/S de los procesos.
3. Tiempo compartido: es una particularidad introducida en los sistemas multiprogramados
en la cual el tiempo de CPU se reparte equitativamente entre todos los procesos, por lo cual
cuando un proceso ha gastado un determinado tiempo de CPU se le suspende y vuelve a la
cola a esperar que le toque de nuevo. En esta forma todos los procesos se van ejecutando
‘por partes’, dando la sensación que se ejecutan todos en forma concurrente. El algoritmo
de distribución de tiempo de CPU más conocido es llamado Round Robin, en el cual los
procesos se les asigna un quantum (q) de tiempo de CPU y cuando lo gastan vuelven al final
de una cola circular (donde están los procesos que deben volver ejecutarse) a esperar que le
toque nuevamente la CPU. Si bien en los sistemas operativos modernos los algoritmos son
más sofisticados utilizan parte de este algoritmo y los valores de q van desde 15 a 150
milisegundos.
4. Llamada al sistema (system calls): es un conjunto de rutinas del sistema operativo que
permiten al programador de aplicaciones o a los comandos pedir que el operativo realice
una operación (por ejemplo, crear un proceso –la llamada para esta acción por ejemplo en
Unix es fork()- o cargar un código binario y ejecutarlo –en Unix la llamada es exec()-). El
programador verá estas llamadas como una función de librería que se incluirán durante la
compilación del código de la aplicación. Conociendo las llamadas al sistema de un operativo,
se conocerá qué servicios prestará ese SO y qué permitirá hacer.
5. Archivos: dado que el sistema informático es gestor-procesador de información (lee datos
de entrada, los procesa a través de un programa y genera datos de salida) es necesario
mantener almacenado de alguna forma los datos de entrada, el programa a ejecutar –incluido
el propio SO- y los datos de salida. Todo esto se realiza a través de las capacidades del SO
para realizar E/S sobre los dispositivos físicos. Para ello se utilizan diferentes sistemas de
 E/S orientados a almacenar bloques de información (discos, cintas, usb, etc.). Estos bloques
se organizan sobre el dispositivo como una unidad lógica (no física), llamada archivos,
donde su contenido representa una información de un tipo (por ejemplo, una imagen) y su
orden es vital para su procesamiento (es equivalente a una hoja de un libro). Estos archivos
pueden ser organizados en compartimientos llamados directorios y se pueden crear, abrir,
leer, escribir, borrar, mover, proteger, etc., a través de las llamadas al sistema. La parte del
SO que gestiona el sistema de archivo es vital para este dado que la confianza y aceptación
de un usuario hacia el sistema operativo vendrá (en su mayor parte) por la robustez en
manejar los archivos del usuario sin perder la información, siendo rápido en el
almacenado/recuperación y si es posible independientemente del tamaño del archivo.
Un concepto adicional, en la mayoría de los casos asociado a los archivos pero no
solamente a ellos, es la protección que debe aportar el sistema operativo para garantizar la
seguridad y protección de la información. Estos mecanismos son necesarios para que, por
ejemplo, un archivo no pueda ser leído por un usuario no autorizado o que un recurso no
pueda ser empleado en una actividad no permitida. Es un tema muy extenso y cada sistema
operativo implementa sus políticas de seguridad y permisos pero a modo de ejemplo se
puede considerar el caso de Linux (o cualquier Unix) que tiene un modo simplificado donde
a cada objeto a proteger (dispositivo, archivo, directorio, etc.) le asigna tres permisos
(lectura, escritura, ejecución) indicados por las letras r,w,x (read, write, execute) y para tres
grupos de usuarios diferentes (dueño del recurso, grupo de trabajo, resto de los usuarios),
agrupándolos en ese orden. Por ejemplo, si tenemos un archivo con la protección rwx r–x
r- -indica que cuando aparece la letra el permiso está concedido y las tres primeras letras son
para el dueño del archivo, las segundas tres letras para el grupo y las tres últimas para el
resto de usuarios indicando en este caso que el dueño tiene los tres permisos concedidos, el
grupo solo podrá leer y ejecutar este archivo y el resto de usuario que no pertenece al grupo
solo podrá leer. Es importante notar que solo el dueño podrá cambiar estos permisos y
agregar/quitar algunos o todos ellos. En Linux podemos ver con el comando ls –l todos
los archivos de un directorio y sus permisos y para cambiarlos se puede utilizar el comando
chmod 755 file.txt donde el 755 representa en octal 111 101 101, correspondiendo a cada
grupo de letras e indicando rwx r-x r-x, o también se podría haber ejecutado chmod o+x
file.txt, lo cual agregaría permiso de ejecución al resto de usuarios (o=other, + agregar, x
permiso de ejecución).
6. Independencia del dispositivo de E/S: es un concepto introducido en sistemas
operativos, como Unix o similares, en los cuales las llamadas al sistema se aplican para todos
los dispositivos de igual tipo, facilitando en forma notable la gestión y administración de los
dispositivos, así como la eficiencia del SO. En Linux/Unix solo se debe ‘montar’ una unidad
de disco sobre un directorio y luego simplemente accediendo a ese directorio se verá el
contenido. Esto facilita que esta unidad puede ser un disco duro, un CD-ROM o un sistema
de archivos compartido por red que se tratará y gestionará de la misma forma representando
una ventaja para el usuario ya que no debe preocuparse por donde está la información. Esto
implica ventajas en la redirección de la entrada salida (por ejemplo, ls > file.txt enviará el
resultado del comando ls -listar un directorio- a un archivo y ls | grep txt | sort > file permitirá
 que la salida de ls se envíe como entrada al comando grep que lo filtrará por el patrón txt y
esta salida se ordenarán por el comando sort que guardará el resultado en el fichero file sin
ningún cambio en los comandos y gestionado de forma general –sin ninguna especificidad
de dónde lee y a dónde escribe- por el intérprete de comandos).
7. Intérprete de comandos (shell): entre todas las herramientas, comandos y utilidades que
dispone un sistema operativo una de ellas, de vital importancia, es el intérprete de comandos
(denominado Shell porque es la capa exterior al núcleo del SO). El Shell acepta la órdenes
de los usuarios, las interpreta verificando su validez (por ejemplo, en la sintaxis) y ejecuta la
acción correspondiente intercediendo con el núcleo del SO. En función del tipo de interfaz
que empleen, los Shells más comunes pueden trabajar en modo texto (llamados CLI -
Command-Line Interface) o modo gráfico (GUI - Graphical User Interface). Algunos
sistemas operativos disponen de un único Shell de cada tipo, pero para otros (en su mayoría,
los de fuente abierto) es posible escoger entre varios.
En Linux, por ejemplo, en modo texto existe un Shell por defecto (llamado bash)
que se ejecuta durante la inicialización de la sesión del usuario pero que puede cambiarse
interactivamente entre los disponibles. El bucle que realiza el Shell (en modo texto) es poner
un símbolo llamado prompt para indicar que está listo para procesar las órdenes del usuario,
leer una orden de teclado, interpretarla, ejecutarla y mostrar nuevamente el prompt. Todo
esto se puede modificar y configurar, por ejemplo, diciendo que no se espere a terminar la
primera orden para aceptar la segunda (procedimiento llamado procesamiento en background
y se indica en Linux poniendo el símbolo & al final del comando). Por ejemplo, si ponemos
en Linux comando  , el Shell creará un proceso hijo que cargará el ejecutable del comando,
lo ejecutará y cuando el proceso hijo termine su ejecución avisará al proceso padre que ha
terminado, pasándole un código que indicará el resultado de la ejecución y el proceso padre
(Shell) podrá nuevamente el prompt. En cambio, si hacemos comando &  , el proceso
padre tan pronto como cree el proceso hijo pondrá el prompt y el proceso hijo será
independiente, realizando su ejecución como un proceso independiente en el SO. En la
mayoría de los sistemas que disponen de entornos gráficos quien realiza la actividad del
Shell es la interfaz de usuario del entorno y es denominado por algunos autores como Shell
gráfico (por ejemplo, en Windows es denominado el proceso explorer.exe –se puede
comprobar abriendo el administrador de tareas y eliminando este proceso. Con esto,
veremos que solo quedan las ventanas de aplicación y desaparece la barra característica de
este sistema operativo. Si se pone en marcha de nuevo desde el mismo administrador de
tareas haciendo en el menú->Ejecutar Tarea e introduciendo explorer.exe, se volverá a tener
todo como antes).
Es importante destacar en que en algunos sistemas operativos con interfaz gráfica,
el gestor de ventanas/Shell es una parte totalmente integrada con el propio SO
(generalmente se dispone también de una interfaz CLI, que se ejecuta en una ventana y que
puede ser más o menos potente) como es el caso de Windows y OS X, mientras que en
otros como, por ejemplo, Linux, hay una separación entre el sistemas gráfico (más común,
XWindow) y el gestor de ventanas/Shell y pueden utilizarse diferentes combinaciones.
 Entre los más comunes se encuentran Gnome, KDE, Cinamon, MATE, Xfce, CDE, etc.
Una lista interesante para conocer las diferencias y ver capturas de pantalla de diferentes
gestores de ventanas y escritorios se puede encontrar en http://xwinman.org/.
8. Multitarea/multiusuario: son dos características de los SO modernos que derivan de la
posibilidad de tener multiprogramación y tiempo compartido. Cuando se indica que un
sistema operativo es multitarea implica que varios procesos se ejecuten al mismo tiempo
(aunque si solo se dispone una CPU estos se ejecutarán en tiempo compartido). Como se
comentó anteriormente, en Linux para lanzar una tarea y que el Shell continúe atendiendo
al usuario se deberá utilizar el símbolo & (por ejemplo ls –R / > archivos.txt & lo cual listará
en forma recursiva todos los archivos comenzando por el directorio raíz y los guardará en
el archivo archivos.txt como un proceso en background). En los SO multitarea, en su gran
mayoría, además permiten que estas tareas puedan ser de diferentes usuarios y con lo cual
el SO se denominará Multitarea+Multiusuario. En estos SO los usuarios accederán al
sistema a través de la red compartiendo los recursos, por lo cual el SO deberá implementar
políticas de compartición y protección para que todos los usuarios tengan un acceso
equitativo a los recursos del sistema y que los procesos de un usuario no afecte a los de los
otros usuarios o que no puedan acceder a ninguna información que no le esté permitida.
Los SO modernos más comunes (Linux/Unix, MacOS, Windows, etc.) permiten ambas
características.

Con los concepto definidos hasta el momento se puede realizar una primera clasificación de los
Sistemas Operativos considerando cómo actúan, se distribuyen y ejecutan las actividades de los
usuarios teniendo diferentes tipos, por ejemplo ‘por lotes’ (batch), multiprogramado, de tiempo
compartido, de tiempo real, distribuidos, de red, etc. No obstante es interesante analizar cómo los
diseñadores de Sistemas Operativos han adoptado diferentes estructuras internas para atender
nuevos requerimientos y solucionar los problemas que la tecnología les presentaba. En esta sección
no se pretende hacer una clasificación exhaustiva de las estructuras internas de los SO sino presentar
las más peculiares y que representan una diferencia considerable a otros diseños entre ellas:
monolíticas, jerárquica o por capas, máquina virtual, micronúcleos
(microkernels/nanokernels/exokernels), por funciones/cliente-servidor.

3.1. Estructura monolítica

Este tipo de diseño se conoce también como “sin estructura”, ya que el sistema operativo se
organiza como un conjunto de procedimientos que se pueden llamar entre sí sin ninguna restricción.
Estos sistemas operativos se caracterizan en que no tienen una estructura clara y prefijada en forma
global ni para cada uno de los servicios que ha de proveer, pero su ejecución es altamente eficiente.
Normalmente el diseño del SO es evolutivo y se van agregando funcionalidades a un conjunto
básico de ellas, por lo cual su crecimiento implica cierto “desorden interno” pero la máxima eficacia,
ya que las funciones y servicios están muy entrelazados, generando un código compacto (que se
ejecuta en el menor espacio posible), difícil de seguir/modificar pero con unas prestaciones muy
buenas.
 Algunos diseños han intentado poner un poco de orden en el caos generado por múltiples
puntos de accesos, salidas, recursividades poniendo unos puntos de entrada predefinidos y
generando un capa de abstracción/organización que permita al usuario interactuar con el SO. Esta
capa de abstracción permite la interacción de las aplicaciones con el núcleo a través de unas llamadas
(system calls) con parámetros fijos para acceder a los servicios y funciones que presta el SO. Con
estos nuevos diseños se logra disponer de una lógica funcional con una mínima organización
disponiendo de:

a) Una función colectora principal que atiende las peticiones de servicio y las envía a los
procedimientos de servicio que son internos en el núcleo del SO.
b) Procedimientos de servicio que llaman a rutinas de código mucho más específicas accesibles
desde cualquier punto interno del SO y que necesite esta funcionalidad.
c) Acceso a los recursos físicos que puede ser realizado desde diferentes puntos del código en
virtud de cual sea el servicio que lo necesita.

Todo esto presenta unas ventajas y desventajas como:

 Ventaja: simplicidad en la comunicación entre módulos mediante llamadas, alta
optimización de código, interfaz simple y homogénea y costo reducido en el diseño y
desarrollo.
 Desventaja: complejidad, difícil depuración y gestión de errores y dificultades en su
modificación (múltiples de puntos de llamada y accesos), políticas de compartición de
recursos compleja y necesidad de recopilación de núcleo cuando hay modificaciones o
cambios en el hardware.
Como ejemplos representativos de esta estructura se puede mencionar UNIX, Linux y FreeBSD (si
bien Linux se considera una estructura monolítica híbrida) pero también DR-DOS/MS-DOS,
Windows 9x (95, 98, 98SE, Me), Mac OS hasta la versión 8.6, VMS (la mayoría de ellos obsoletos).
Es necesario mencionar que algunos autores consideran parcialmente monolíticos los sistemas
operativos Windows basados en el núcleo NT (2k, XP, Vista, Server2003/08, W7-8). No obstante,
en este documento se considerarán como estructuras híbridos.

En los sistemas *Nix (se utiliza esta abreviación para definir todos los sistemas Unix-Linux
equivalentes) ha habido diversas reorientaciones en el diseño para adaptarlos a nuevas necesidades
de flexibilidad como, por ejemplo, el sistema de módulos cargables en tiempo de ejecución, lo cual
lo acerca más a otras estructuras por ejemplo de micronúcleo. Estas ventajas de módulos flexibilizan
la integración de nuevas funcionalidades/dispositivos al núcleo, quedando integrados en este, pero
que puede ser cargado y descargado en tiempo de ejecución.

Es interesante ver un mapa interactivo del núcleo de Linux en

http://www.makelinux.net/kernel_map/ cuya imagen se muestra a continuación y en donde se
pueden ver las interacciones y relaciones entre las diferentes llamadas y funciones:
 Imagen 12. Mapa interactivo del núcleo de Linux.

Fuente: http://www.makelinux.net/kernel_map/

3.2. Estructura jerárquica o por capas

Este tipo de estructura de diseño surge como la necesidad de ordenar las funcionalidades, dotar
de seguridad y facilitar la modificación y evolución del SO. En un principio los diseños dividieron
al SO por funcionalidad con unidades en capas perfectamente definidas y con una interfaz declarada
y única entre ellas. Como primer ejemplo de estos diseños se puede mencionar el THE -Technische
Hogeschool, Eindhoven-, desarrollado por el Prof. Dijkstra con finalidades académicas y que
contaba con 6 capas:

Capa 5 •Operador de THE

Capa 4 •Programas del usuario

Capa 3 •Administración de Entrada/Salida

Capa 2 •Comunicación entre el operador y el proceso

Capa 1 •Administración de la memoria y disco

Capa 0 •Distribución del procesador y multiprogramación

 Figura 1. Estructura de capas de THE.

Fuente: http://www.cs.utexas.edu/users/EWD/ewd01xx/EWD196.PDF

Los diseños de este tipo evolucionaron a formas por capas concéntricas (estructura
comúnmente llamada Onion –cebolla-) definiendo que la comunicación solo se podía hacer entre
capas adyacentes, siendo las capas interiores más cercanas a los dispositivos hardware que las
superiores. En estos sistemas la interfaz con el núcleo se realizaba a través de puntos bien definidos
(igual que los SO monolíticos evolucionados), con un mecanismo similar a las llamadas al sistema
con parámetros acordados. Muchos diseñadores adoptaron este tipo de organización ya que
facilitaba el diseño y permitía hacer desarrollos con grupos de trabajos diferentes y en paralelo, ya
que la ventaja principal radicaba en la independencia entre las capas y lo cual facilitaba su
programación individual y la depuración aislada. Unas de las desventajas importantes de esta
estructura, que derivaba también de la independencia, era que quien diseñaba el SO debía tener muy
claro la definición de las funcionalidades/capas, ya que al solo poder utilizar servicios en el anillo
interior complicaba la definición e implementación de servicios complicando extremadamente el
diseño. Además como solo se podía hacer intercambio de información entre una capa y la siguiente,
esto implicaba un costo que se transformaba en una pérdida de eficiencia para ir de las acciones en
las capas más exteriores hacia las más interiores.

Ejemplo de estos sistemas (además del THE) se pueden mencionar Multics (Multics, 1965)
(ver sección anterior) y que presentaban una estructura en anillos equivalente a la siguiente figura:

HW

Gestión de
Memoria
Gestión de
Procesos

Gestión de E/S

Programas-
Comandos-Shell

Figura 2. Estructura en anillos.

Fuente: extractado de http://www.multicians.org/

 3.3. Estructura de máquina virtual
Esta arquitectura de sistemas operativos se caracteriza por presentar una interfaz única a cada
proceso donde el proceso “ve” una máquina que parece idéntica a la máquina real subyacente. Esta
técnica, muy utilizada en nuestros días con los procesadores modernos, accede a que sobre un
sistema operativo base (host), que permita estas extensiones, se pueda integrar otros sistemas
operativos atendiendo a sus procesos sobre el mismo hardware que donde se ejecuta el host. El núcleo
de estos sistemas operativos se denomina monitor virtual y tiene como misión llevar a cabo la
multiprogramación, presentando a los niveles superiores tantas máquinas virtuales como se
soliciten. Estas máquinas virtuales no son máquinas extendidas, sino una réplica de la máquina real,
de manera que en cada una de ellas se pueda ejecutar un sistema operativo diferente, que será el que
ofrezca la máquina extendida al usuario.

Estas técnicas han evolucionado de forma continua, sobre todo a partir de la incorporación en
los procesadores (desde 2005/6) de extensiones específicas para facilitar la virtualización llamadas
(Intel VT y AMD-V). Esto ha favorecido una evolución de la virtualización completa con soporte
hardware permitiendo que sobre sistemas operativos normales (por ejemplo, VirtualBox sobre
Windows o MacOS) o con extensiones (KVM sobre Linux) se puedan ejecutar hipervisores (gestor
de la virtualización o monitor de máquina virtual) sobre los cuales se instalan otros sistemas
operativos independientes. En estos casos los hipervisores se llaman de Tipo 1 a diferencia de los
de Tipo 2 que no necesitan un SO host (ejemplos de estos son Xen, Hyper-V, Vmare ESX/i).

HW
Sistema Operativo
(Host)/Hipervisor
HW Virt. HW Virt. HW Virt. HW Virt.

MV1: MV2: MV3: MV4:

Linux W10 W7 FreeBSD

Figura 3. Estructura virtualizada.

Fuente: elaboración propia.

Las primeras aportaciones en esta estructura fue VMOS -Virtual Machine Operating System-
(o también llamado VM/CMS) de IBM, que fue utilizado los mainframes System/370/390 o en las
zSeries y cuya evolución, después de 45 años, es la IBM z/VM Version 6.3 (2013) y se ejecuta sobre
los sistemas IBM System z13. Estas ideas han sido fundamentales (juntas a las de la Universidad de
Cambridge, MIT, Harvard, los trabajos de Popek & Goldberg y muchos otros) en la virtualización
de SO en la actualidad y, a pesar de diferentes ideas, tecnología y conceptos, la esencia de la
estructura subyace en los diseños más modernos.

3.4. Estructura por funciones

Otra de las estructuras aplicadas al diseño de SO es la conocida como separación por funciones
donde las agrupaciones se realizan según el tipo de servicio que se debe dar sin considerar la
proximidad al hardware. Estas agrupaciones se pueden crear a partir de servicios de entrada/salida,
la gestión de procesos, la gestión de la memoria, etc., teniendo en cuenta que cuando se desarrolla
el SO esta estructura presenta un organización vertical (y no por capas como la descrita
anteriormente). Esto presenta problemas de diseño ya que si bien a nivel funcional se pueden tener
muy definidas las actividades, existen, en el desarrollo, fronteras difusas que son complicadas de
gestionar como, por ejemplo, gestión de entrada/salida y gestión de ficheros, o gestión de procesos
y gestión de la memoria. A pesar de esta zona indefinida, la solución viene, al igual que otras
estructuras, de la imposición de puntos de acceso a las llamadas al sistema y con parámetros
acotados y definidos.

Desde el punto de vista de la implementación, los SO con estructura funcional se pueden

construir con el modelo cliente/servidor o con programación por objetos. En ambos casos, el
objetivo es el mismo: dar a las aplicaciones una colección de servicios que son provistos por
determinados procedimientos con entidad propia, sean servidores, sean objetos. Un esquema de la
estructura es la siguiente:

Aplicaciones

Núcleo

HW
Figura 4. Estructura por funciones.

Fuente: Suppi (2011).

El núcleo en este caso tiene por objetivo establecer la comunicación entre los clientes y los
servidores. Los procesos pueden ser tanto servidores como clientes. Por ejemplo, un programa de
aplicación normal es un cliente que llama al servidor correspondiente para acceder a un archivo o
realizar una operación de entrada/salida sobre un dispositivo concreto. A su vez, un proceso cliente
puede actuar como servidor para otro. Esta estructura ofrece gran flexibilidad en cuanto a los
servicios posibles en el sistema final, ya que el núcleo provee solamente funciones muy básicas de
memoria, entrada/salida, archivos y procesos, dejando a los servidores la mayoría de los servicios
que el usuario final o programador puede utilizar. Estos servidores deben tener mecanismos de
seguridad y protección que, a su vez, serán filtrados por el núcleo que controla el hardware. Una
extensión a esta arquitectura es que los clientes y servidores ya no se encuentren en el mismo
hardware teniendo una visión de sistema operativo distribuido sobre una red como se mostraría en
la siguiente figura:

Cliente Servidor de ... Servidor de ... Servidor de ...

Núcleo Núcleo Núcleo Núcleo

HW HW HW HW
Red
Comunicación
entre cliente y
servidor

Figura 5. Estructura por servicios.

Fuente: Tanenbaum (2009).

3.5. Micronúcleos, nanonúcleos y exonúcleos

El paradigma del micronúcleo (microkernels) tuvo un momento de gran auge (sobre todo en
entornos académicos) en la década de los 80 y principios de los 90, ya que el interés estaba puesto
en sistemas que fuesen capaces de superar por sí mismos errores de software o hardware (self healing
computing). El micronúcleo surge como necesidad de lograr mayor confiabilidad, con técnicas de
dividir y conquistar (divide & conquer) sobre la estructura y módulos del SO. Estos adoptan una
estructura que solo permite que uno de ellos se pueda ejecutar en modo de alta prioridad (modo
kernel), mientras que el resto se ejecuta en modo usuario y con ello se reducen las probabilidades
que un error o actividad no permitida pueda bloquear al sistema operativo como podría pasar en
un sistema monolítico o por capas, donde todo se ejecuta en modo privilegiado. En estos núcleos
un error en un módulo de atención a un dispositivo o un error hardware del dispositivo dejaría sin
esa funcionalidad pero el SO continuaría funcionando. Esto no ocurriría si el controlador del
dispositivo (driver) está en modo kernel como, por ejemplo, en un sistema monolítico, y ocurre una
referencia inválida a memoria (segmentation fault), la cual podría hacer que causara un bloqueo y
parada de emergencia del SO (como resultado de un Kernel Panic).

En resumen se puede enumerar que las principales ventajas de un micronúcleo son la reducción
de la complejidad, la descentralización de los fallos y la facilitación para crear y depurar módulos y
controladores de dispositivos. Entre sus principales desventajas son la complejidad en la
sincronización de todos los módulos que componen el micronúcleo y su acceso a la memoria, y la
Integración con las aplicaciones. Entre los SO con micronúcleo más conocidos se puede citar: AIX,
Minix, Hurd, Mach, OpenSTEP/NeXTSTEP (algunos autores consideran este último es un núcleo
híbrido), Netkernel, RadiOS, QNX, Symbian, etc.

La figura siguiente muestra la comparación entre estructuras de SO basadas en una organización

monolítica, micronúcleo e híbrida y donde se puede apreciar la influencia de la ejecución privilegiada
de todo el núcleo en los monolíticos, solo una parte muy pequeña en los micronúcleos o una
inclusión de determinadas servicios más cercanos al núcleo en los híbridos (por ejemplo, el
mecanismo de comunicación entre procesos).

Figura 6. Comparación de diferentes estructuras de núcleos.

Fuente: Wikipedia.

Esta arquitectura de micronúcleo más servicios en espacio de núcleo, con el objetivo de

mejorar sus prestaciones y aumentar así el bajo rendimiento de los micronúcleos puros, ha dado pie
al diseño de la mayoría de SO “modernos” entre los más populares Windows NT, XNU (ahora
conocido como Darwin que es el núcleo de Mac OS X y iOS, y está basado en un micronúcleo
modificado, debido a la inclusión de código del núcleo de FreeBSD en el núcleo original basado en
Mach) y DragonFlyBSD (que es el primer sistema BSD que adopta una arquitectura de núcleo
híbrido sin basarse en Mach).

Como ideas complementarias a los micronúcleos son las arquitecturas basadas en nanokernel
o picokernel y exokernel. Los nanokernels se caracterizan porque la cantidad de código que se ejecuta en
el modo privilegiado del hardware es muy pequeña (el término picokernel se utiliza por algunos autores
para resaltar esta mínima cantidad de código en espacio kernel). El término nanokernel proviene de J.
Shapiro, de su artículo “The KeyKOS NanoKernel Architecture” donde muestra, a diferencia de
Mach, la base de esta arquitectura y donde existe una capa de abstracción mínima del hardware que
gestiona las interrupciones y funcionalidades esenciales y sobre la cual se asientan los servicios y
funciones del sistema operativo.

El exokernel es un conjunto de ideas para el desarrollo de un núcleo de sistema operativo del

Massachusetts Institute of Technology (MIT) donde la pieza clave de la decisión del diseño está en
la abstracción del hardware y su control. Con el objetivo de minimizar el tamaño del núcleo solo
incluyen funcionalidad mínima para garantizar la protección y el multiplexado de los recursos
quedando por ello más pequeños que los micronúcleos. El funcionamiento se completa
permitiendo que las aplicaciones actúan puedan solicitar direcciones específicas de memoria,
bloques de disco, etc., dejando para el exonúcleo la potestad de dar paso (o no) a este recurso si
está disponible, con lo cual se obtiene una implementación muy eficiente y un rendimiento óptimo.

Conclusiones

En este apartado se han descrito las estructuras más interesantes de SO y, si bien se han
mencionado algunos ejemplos, se tiene que considerar que la mayoría no son diseños o
implementaciones puras de estos modelos/arquitecturas. Generalmente, los diseñadores parten de
unas ideas generales pero que la van adaptando a las necesidades, a la propia evolución de los SO y
utilizando los recursos de la forma más adecuada para la tecnología disponible (tanto hardware como
software).

Se puede observar que como premisa general se parte de la idea que para los servicios que deben
controlar dispositivos de hardware es conveniente que las funciones estén divididas por capas u
objetos para lograr independencia del hardware y no bloquear todo el SO por un cambio de un
dispositivo. Por el contrario, cuando se habla de gestión de procesos, memoria, interrupciones, etc.,
lo más importante es que el código sea eficiente y óptimo, por lo cual las estructuras organizativas
utilizadas son equivalentes a la de “por funciones”. No obstante, la mayoría de los SO actuales se
dividen entre monolíticos/monolíticos híbridos con evoluciones en la estructura interna (ya sea por
capas parciales o por funciones) o micronúcleos híbridos y en estos (y algunos casos) con mayor o
menor incidencia del concepto puro de micronúcleo.

4. Caso de uso

A continuación se realizará un análisis comparado de algunas de las partes más significativas a

nivel usuario en un Sistema Operativo Gnu/Linux (Debian 8.0 con el gestor de ventanas Gnome)
y Windows (versión 7/10). No es una secuencia exhaustiva y solo se presenta a modo de ejemplos
para mostrar su equivalencia. Los temas internos de gestión y administración a nivel de usuario
avanzado se considerarán en los módulos siguientes. En ambos sistemas se trabajará en modo
gráfico aunque en Linux también es posible trabajar en modo texto (el modo texto en Linux es
generalmente utilizado cuando se trabaja remotamente o en servidores)30.

4.1. Carga del sistema operativo e inicio (login)

La carga del sistema operativo se inicia a través de una secuencia de pasos automáticos (o
semiautomáticos) por un módulo llamado cargador (loader) y esto termina con el procedimiento de
introducción de usuario y palabra clave. En Linux el cargador más común se llama Grub y permite
la posibilidad de escoger el núcleo/opciones (incluso otro sistema operativo) a cargar. En algunas
distribuciones puede estar oculto pero presionando la tecla Esc se podrá ver se podrá ver este menú.
En Windows deberemos apretar F8 para acceder a las opciones de carga (con/sin módulos, modo

30Todas las capturas de pantallas a continuación son obtenidas de Debian8 y Windows7/10® ejecutándose
virtualizadas en máquinas del autor.
seguro etc.). Las dos imágenes a continuación muestra el procedimiento de carga de ambos sistemas
operativos:

Una vez finalizado este procedimiento se llega a la pantalla de inicio donde el usuario deberá
introducir un usuario y una palabra clave (password) que le permitirá acceso al sistema. Todos los
sistemas *Nix (abreviatura de Unix, Linux o equivalentes) consideran dos tipos de usuarios
diferenciados: el superusuario (llamado root), que tiene todos los permisos sobre el sistema, y el
resto de los usuarios. Generalmente todos los usuarios tienen su directorio de trabajo (generalmente
con el mismo nombre del usuario y con todos los privilegios) dentro del directorio /home y el usuario
root su directorio habitual de trabajo (home) se encuentra en /root, Los usuarios tienen permisos
restringidos en el resto de directorios que no sean su home limitados generalmente a leer o ejecutar
si es posible. En la interfaz gráfica de Linux (en la mayoría de las distribuciones), por cuestiones de
seguridad, el usuario no puede entrar como root sino deberá hacer como un usuario normal y
después ‘escalar’ privilegios con el comando su o ejecutar comando privilegiado con el comando
sudo (aunque esto es configurable y se puede cambiar, aunque no es recomendable). En Windows
el usuario puede pertenecer al grupo administradores que tendrá todos los permisos y si accede
como usuario que forme parte del grupo administradores tendrá permisos para hacer todo dentro
del sistema operativo (es recomendable no trabajar con un usuario con permisos de administrador).
Los usuarios en Windows están definidos en la primera unidad física visible del SO (generalmente
C:) en un directorio c:\Users (o Usuarios dependiendo del idioma configurado) donde hay otras
carpetas predefinidas (como default, default user) que contienen archivos comunes o que sirven como
base para la definición de nuevos usuarios.
Como se puede observar, ambas pantallas de entrada (login) tienen opciones para cuestiones de
accesibilidad, mayor o menor cantidad de información y opciones para cambiar de usuario,
reiniciar/suspender o apagar la máquina. Se debe indicar que todo esto es configurable y el usuario
puede cambiarlo a su gusto.

Una vez que se ha ingresado se tendrá la pantalla principal de trabajo llamado escritorio,
que será el sitio principal de trabajo. Como se mencionó anteriormente, en los sistemas *Nix se
puede trabajar interactivamente en dos modos diferenciados: modo texto y modo gráfico (y en este
último se puede abrir una aplicación en una ventana especial llamada Terminal, que permite trabajar
en modo texto dentro del modo gráfico). Normalmente, los modos gráficos son los más utilizados
en sistemas de escritorio o de usuario doméstico, mientras que los de texto son adecuados para
servidores. No obstante, como no se impone ninguna restricción se puede cambiar fácilmente de
uno a otro con una secuencia de teclas (generalmente Crtl+Alt+F1 a F6 per a pasar a modo texto
-6 posibles terminales texto disponibles concurrentes- y Crtl+Alt+F7 para retornar a modo gráfico
–considerar que todas las sesiones son simultáneas por lo cual lo que esté haciendo en la terminal 1
se ejecuta simultáneamente con lo que haga en la terminal 2 o en modo gráfico-) o incluso estar en
modo gráfico y desarrollando código en modo texto sobre un terminal, o conectado con un terminal
a otra máquina o al disco de otra máquina. En Windows se trabaja siempre en modo gráfico, aunque
es posible también abrir una terminal (ventana de comandos) para ejecutar comandos o secuencia
de ellos.

La interacción en modo texto entre el usuario y el núcleo se realiza a través de un intérprete

de comandos/órdenes llamado Shell, que permite la ejecución de comandos en forma interactiva
(un comando por vez) o secuencial por medio de pequeños programas llamados shell scripts
(secuencia de comandos que incluyen sentencias de control y variables en un archivo de texto ASCII
y que serán interpretados secuencialmente por el Shell). En Linux el intérprete de comandos por
defecto se denomina Bash, pero se puede cambiar a otro de todos los posibles, y en Windows se
puede abrir una consola (comando cmd) para ejecutar comandos o scripts (similares a los que tenía
MS-DOS). No obstante, Windows en sus versiones actuales incluye (desde la versión Vista) una
utilidad llamada PowerShell, que es una interfaz de consola CLI (Command-line interface), mucho más
potente que la anterior cmd, diseñada para administradores de sistemas, y ofrece una interfaz similar
a los Shell actuales de los sistemas *Nix. A continuación se muestran los escritorios de Debian-
Gnome y de Windows 7 con sus barras de tareas características y acceso a las opciones y programas
(en Debian con una terminal con bash, en W7 con una ventana de cmd –color negro- y una de
powershell –color azul-).

Puede parecer que uno tenga más opciones/comandos que otro, pero no es así ya que los
modos de acceder a los programas opciones son equivalentes pero con filosofías de
mostrar/acceder diferentes.

Uno de los apartados que necesitamos acceder una vez que estamos dentro del escritorio
son las configuraciones de las diferentes partes del sistema operativo. Para acceder a ellas en Debian
solo debemos acceder al botón Activities y en la caja de búsqueda poner Settings (o Configuración
si lo tenemos en castellano), o simplemente hacer clic en el ícono de la izquierda (debajo del ícono
del navegador) que abrirá el panel de control con todas las aplicaciones y seleccionar, entre ellas, la
de Settings. En Windows podemos ir al botón izquierdo de la barra de tareas y hacer clic en el botón
de panel de control (en Windows 8 que incluye la interfaz Metro, que permite trabajar con
dispositivos de pantalla táctil, solo debemos hacer clic sobre el ícono de Windows en la barra de
tarea con el botón derecho, y sobre Windows 10 nuevamente hacer clic sobre el ícono de Windows
e ir a Setting –o Panel de Control-). En estos paneles de Control se encontrarán todas las opciones
para configurar todos los aspectos del Sistema Operativo (en Linux veremos que es posible trabajar
con opciones avanzadas pero se deberá hacer sobre un Terminal, no obstante el Panel de Control
tiene todo lo necesario para un usuario habitual). Las imágenes a continuación muestran ambos
paneles de control (primero el de Debian-Gnome luego el de Windows 7 y Windows 10).
 Una de las opciones iniciales más utilizada es la configuración a la red. La conexión a la red
se puede realizar a través de una red cableada (llamada Ethernet) que presenta una conexión similar
a la de los teléfonos fijos, pero más anchos (de 6 pines) o inalámbrica (conocida como Wifi). En
todos los sistemas operativos (generalmente por defecto) la conexión a red viene seleccionada para
una configuración automática (conocida como servicio dhcp) y el usuario solo deberá conectar el
cable si es Ethernet o seleccionar la red e introducir la clave de acceso a esa red si es Wifi y el router
gestor de la red y que permitirá la conexión a Internet proveerá todos los parámetros necesarios de
conexión y el usuario no deberá realizar ninguna acción (excepto en Wifi seleccionar la red e
introducir la clave). Esto parámetros, necesarios para la conexión a cualquier red, son 4 y tienen el
formato de 4 números separados por puntos, cada uno de ellos entre 0 y 255, por ejemplo
192.168.1.10. Como se dijo anteriormente si el usuario lo tiene configurado de forma automática
no deberá introducir ninguno de ellos, o en caso contrario los deberá consultar con su administrador
de red. Ellos son: dirección IP que identifica la dirección de la máquina en la red (por ejemplo
192.168.0.25), máscara indica en qué red está y cómo debe hacer las consultas, generalmente
255.255.255.0, puerta de interconexión (gateway) que es la dirección del router por donde se conectará
la máquina a otras redes o Internet, y servidor de nombres (conocido como DNS), que es un servicio
que nos permite transformar un dirección como http://www.umb.edu.co/ en la dirección IP de
la máquina 190.242.126.11 necesaria para la interconexión de navegador y el servicio web que aloja
la página de la universidad.
 A modo de ejemplo se muestra la secuencia de configuración de una red Ethernet en
Windows 7 (en este caso se encuentra en forma automática) y donde se pueden ver los parámetros
de configuración.

1. Configuración
Ethernet

La configuración de las opciones de red de los restantes sistemas operativos es similar a igual el
resto de las opciones de configuración.
5. Glosario

API (Application Programming Interface): conjunto de rutinas, protocolos y herramientas para

construir aplicaciones informáticas.
BIOS (Basic Input/Output System): monitor para la entrada/salida que se popularizó con el PC.
Cloud: recursos y servicios disponibles en Internet y generalmente basados en políticas de “pago
por uso/acceso”. Se caracterizan por su ubiquidad, compartición, solicitud bajo demanda y
conveniencia del usuario.
Emulador: software que permite reproducir el comportamiento de un programa en una plataforma
(ya sea hardware o sistema operativo) diferente de la plataforma para la cual fue escrito originalmente.
Firmware: software generalmente grabado en un memoria de solo lectura y que contiene rutinas
básicas para el funcionamiento del dispositivo (por ejemplo, el BIOS).
Hardware: partes físicas de un sistema informático.
Hilo (thread): sección de código de una aplicación informática que puede ejecutarse
concurrentemente con otra sección de código compartiendo memoria principal. Si la arquitectura
dispone de más de un núcleo dos thread se podrán ejecutar en forma simultánea (en paralelo) en
caso contrario se ejecutarán en tiempo compartido.
Hypervisor: ver vitualización.
Internet de las Cosas (Internet of Things, IoT): nueva tendencia sobre la conexión de elementos
de la vida cotidiana a Internet (por ejemplo, autos, ropa, electrodomésticos, sensores, etc.)
Kernel: núcleo del sistema operativo. Generalmente, la parte más interna y vital del código que
conforma el Sistema Operativo.
Llamada al sistema (system calls): conjunto de rutinas que permiten interactuar a las aplicaciones
con el núcleo del sistema operativo.
Shell: aplicación que actúa como intérprete de órdenes del usuario y utilizando las llamadas al
sistema ejecuta una determinada acción o comando.
Software: código que permite realizar una determinada acción o que tiene un objetivo y se ejecuta
o actúa sobre los dispositivos físicos que componen un sistema informático. Las aplicaciones
informáticas o el sistema operativo son conocidas como el software de un sistema informático.
Virtualización: técnica mediante la cual se simula una infraestructura tecnológica (plataforma
hardware, sistema operativo, dispositivo de entrada/salida, etc.). Esta capa software permite hacer una
abstracción de los recursos de un ordenador y se denomina Hypervisor o VMM (Virtual Machine
Monitor).
6. Bibliografía

Bach, M. (1986). The Design of the UNIX Operating System. Estados Unidos: Pearson Prentice Hall.
Benvenutti, C. (2006). Understanding Linux Network Internals. Estados Unidos: O'Reilly Media.
Carretero, J. (2010). Sistemas Operativos - Una Visión Aplicada. México: MC Graw Hill.
Dijkstra, E. (s.f.). The structure of the 'THE'-multiprogramming system (EWD-196). Center for American
History, University of Texas at Austin. Disponible en:
http://www.cs.utexas.edu/users/EWD/ewd01xx/EWD196.PDF
Goldstine, H., & Goldstine, A. (1946). The Electronic Numerical Integrator and Computer (ENIAC).
Mathematical Tables and Other Aids to Computation 2 (15): 97–110. doi:10.2307/2002620.
Disponible en:
http://www.jstor.org/stable/2002620?origin=crossref&seq=1#page_scan_tab_contents
Friend, J. (s.f.). Emulador MacOS 7 [figura]. Disponible en: https://jamesfriend.com.au/pce-js/-

Futurist. (s.f.). Línea de tiempo (parcial) [imagen]. Disponible en: http://futurist.se/gldt/

Jorba, J. & Suppi, R. (2014). Administración avanzada del sistema operativo GNU/Linux.
Disponible en:
https://www.exabyteinformatica.com/uoc/Informatica/Administracion_avanzada_del_sistem
a_operativo_GNU_Linux/Administracion_avanzada_del_sistema_operativo_GNU_Linux_(I
ntro).pdf.
KVM. (Kernel-based Virtual Machine). (s.f.). Ffull virtualization for Linux on x86 hardware
containing virtualization extensions (Intel VT or AMD-V). Disponible en: http://www.linux-
kvm.org/page/Main_Page
Make Linux (s.f.). Mapa interactivo del núcleo de Linux [imagen]. Disponible en:
http://www.makelinux.net/kernel_map/

Multicians. Org. (s.f.). Estructura en anillos [figura]. Disponible en: http://www.multicians.org/

Multics. (1965). Multics (Multiplexed Information and Computing Service). The mainframe
timesharing operating system 1965-2000. Disponible en: http://www.multicians.org/
Nutt, G. (2006). Sistemas Operativos. Pearson Educación.
Par, J. (s.f.). Windows 1.0 y Windows 3.0 [figura]. Disponible en:
http://jsmachines.net/demos/pc/cga-win101/xt-cga-win101.xml

Peterson, P., & Silberschatz, A. (1994). Conceptos de sistemas operativos: conceptos fundamentales. México:
Editorial Reverté.
Silberschatz, A. (2000). Sistemas Operativos. México: Addison Wesley Longman.
Sisk, J., VanArsdale, S., & Heights, H. (1985). Exploring The Pick Operating System. Estados Unidos:
Hayden Book Co.
Stalling, W. (2004). Sistemas Operativos. México: Pearson Prentice Hall.
______. (2011). Operating Systems: Internals and Design Principles. México: Pearson Prentice Hall.
Suppi, R., & Marzo, J. (2011). Diseño de sistemas operativos. Conceptos estructurales y funcionales del sistema
operativo. FUOC - Eureca Media SL.
Tanenbaum, A. (2009). Sistemas Operativos Modernos. México: Pearson.
Tanembaum, A. & Woodhull, A. (1996). Sistemas Operativos. México: Pearson Prentice Hall.
Vahalia, U. (1995). UNIX Internals: The New Frontiers. Estados Unidos: Pearson Prentice Hall.
Virtualbox. (s.f.). A powerful x86 and AMD64/Intel64 virtualization product for enterprise/home use.
Disponible en: https://www.virtualbox.org/
Von Neumann, John. (1945). First Draft of a Report on the EDVAC. United States Army
Ordnance Department. University of Pennsylvania. Moore School of Electrical Engineering.
University of Pennsylvania. En Godfrey, M. (1993). Annals of the History of Computing, 15 (4),
pp.27-75. Disponible en:
https://web.archive.org/web/20130314123032/http://qss.stanford.edu/~godfrey/vonNeum
ann/vnedvac.pdf.
Wikimedia (s.f.). Computadores Colossus Mark II y Eniac de programa integrado (1944 y 1946)
[imagen]. Disponible en: https://commons.wikimedia.org/wiki/File:Colossus.jpg

Wikipedia (s.f.). IBM360-20 –la más pequeña de la familia- e IBM2560 MFCM [imagen].
Disponible en: https://en.wikipedia.org/wiki/IBM_System/360)

_____. (s.f.). Línea de tiempo en el desarrollo de Windows [imagen]. Disponible en:

https://en.wikipedia.org/wiki/Timeline_of_Microsoft_Windows

_____. (s.f.). Comparación de diferentes estructuras de núcleos [figura]. Disponible en:

https://es.wikipedia.org/wiki/Archivo:OS-structure2.svg