INSTITUTO TECNOLOGICO DE CIUDAD JUAREZ

HISTORIA Y
EVOLUCION DE LOS
SISTEMAS
OPERATIVOS
SISTEMAS OPERATIVOS

Luis Alejandro Saucedo Devora

2-11-2018
Indice
Introducción. ................................................................................................................................................. 2
El Sistema Operativo como Interfaz Usuario/Computadora ........................................................................ 2
Facilidad de evolución de un sistema operativo ........................................................................................... 4
Evolución de los sistemas operativos ........................................................................................................... 5
Proceso en serie ........................................................................................................................................ 5
Sistemas sencillos de proceso por lotes ................................................................................................... 6
Sistemas por lotes con multiprogramación .............................................................................................. 8
Sistemas de tiempo compartido ............................................................................................................... 8
Conclusión. .................................................................................................................................................... 9
Bibliografía .................................................................................................................................................... 9
Introducción.
Sin el software, una computadora no es más que una masa metálica sin utilidad. Con el software, una
computadora puede almacenar, procesar y recuperar información, encontrar errores de ortografía en
manuscritos, tener aventuras e intervenir en muchas otras valiosas actividades para ganar el sustento.

El software para computadoras puede clasificarse en general en dos clases: los programas de sistema, que
controlan la operación de la computadora en sí y los programas de aplicación, los cuales resuelven
problemas para sus usuarios. El programa fundamental de todos los programas de sistema es el sistema
operativo (SO), que controla todos los recursos de la computadora y proporciona la base sobre la cual
pueden escribirse los programas de aplicación.

El Sistema Operativo como Interfaz Usuario/Computadora

El hardware y el software que se utilizan para proveer de aplicaciones a los usuarios pueden contemplarse
de forma estratificada o jerárquica, como se muestra en la figura 2.1. Al usuario de estas aplicaciones se
le llama usuario final y, generalmente, no tiene que ocuparse de la arquitectura del computador. Por
tanto, el usuario final ve al sistema informático en términos de aplicaciones. Las aplicaciones pueden
construirse con un lenguaje de programación y son desarrolladas por programadores de aplicaciones. Si
se tuviera que desarrollar un programa de aplicación como un conjunto de instrucciones máquina que
sean del todo responsables del control del hardware, se tendría una tarea abrumadora y compleja. Para
facilitar esta tarea, se ofrecen una serie de programas de sistemas. Algunos de estos programas se
denominan utilidades e implementan funciones muy utilizadas que ayudan a la creación de los programas,
la gestión de los archivos y el control de los dispositivos de E/S. Los programadores hacen uso de estos
servicios en el desarrollo de una aplicación y ésta, mientras se está ejecutando, invoca a estas utilidades
para llevar a cabo ciertas acciones. El programa de sistemas más importante es el sistema operativo. El
sistema operativo oculta al programador los detalles del hardware y le proporciona una interfaz cómoda
para utilizar el sistema. Actúa como mediador, facilitándole al programador y a los programas de
aplicación el acceso y uso de todas esas características y servicios.

De forma resumida, un sistema operativo ofrece servicios en las áreas siguientes:

• Creación de programas: El sistema operativo ofrece una variedad de características y servicios, tales
como los editores y los depuradores (debuggers), para ayudar al programador en la creación de
programas. Normalmente, estos servicios están en forma de programas de utilidad que no forman
realmente parte del sistema operativo, pero que son accesibles a través del mismo.

• Ejecución de programas: Para ejecutar un programa se necesita un cierto número de tareas. Las
instrucciones y los datos se deben cargar en la memoria principal, los archivos y los dispositivos de E/S se
deben inicializar y se deben preparar otros recursos. El sistema operativo administra todas estas tareas
para el usuario.

• Acceso a los dispositivos de E/S: Cada dispositivo de E/S requiere un conjunto propio y peculiar de
instrucciones o de señales de control para su funcionamiento. El sistema operativo tiene en cuenta estos
detalles de modo que el programador pueda pensar en forma de lecturas y escrituras simples.
• Acceso controlado a los archivos: En el caso de los archivos, el control debe incluir una comprensión, no
sólo de la naturaleza del dispositivo de E/S (controlador de disco, controlador de cinta) sino del formato
de los archivos y del medio de almacenamiento. Una vez más, es el sistema operativo el que se encarga
de los detalles. Es más, en el caso de sistemas con varios usuarios trabajando simultáneamente, es el
sistema operativo el que brinda los mecanismos de control para controlar el acceso a los archivos.

• Acceso al sistema: En el caso de un sistema compartido o público, el sistema operativo controla el acceso
al sistema como un todo y a los recursos específicos del sistema. Las funciones de acceso pueden brindar
protección, a los recursos y a los datos, ante usuarios no autorizados y debe resolver los conflictos en la
propiedad de los recursos.

• Detección y respuesta a errores: Cuando un sistema informático está en funcionamiento pueden

producirse varios errores. Entre estos se incluyen los errores internos y externos del hardware, tales como
los errores de memoria, fallos o mal funcionamiento de dispositivos y distintos tipos de errores de
software, como el desbordamiento aritmético, el intento de acceder a una posición prohibida de memoria
y la incapacidad del sistema operativo para satisfacer la solicitud de una aplicación. En cada caso, el
sistema operativo debe dar una respuesta que elimine la condición de error con el menor impacto posible
sobre las aplicaciones que están en ejecución. La respuesta puede ser desde terminar el programa que
produjo el error, hasta reintentar la operación o, simplemente, informar del error a la aplicación.

• Contabilidad: Un buen sistema operativo debe recoger estadísticas de utilización de los diversos
recursos y supervisar los parámetros de rendimiento tales como el tiempo de respuesta. Para cualquier
sistema, esta información es útil para anticiparse a la necesidad de mejoras futuras y para ajustar el
sistema y así mejorar su rendimiento. En un sistema multiusuario, la información puede ser utilizada con
propósito de cargar en cuenta.
Facilidad de evolución de un sistema operativo
Un sistema operativo importante evolucionará en el tiempo por una serie de razones:

• Actualizaciones del hardware y nuevos tipos de hardware: Por ejemplo, las primeras versiones de UNIX
y OS/2 no empleaban mecanismos de paginación, porque funcionaban en máquinas sin hardware de
paginación. Las versiones más recientes se han modificado para aprovechar las capacidades de
paginación. Además, el empleo de terminales gráficos y terminales de pantalla completa, en lugar de los
terminales de líneas, pueden influir en el diseño de los sistemas operativos. Por ejemplo, un terminal de
éstos puede permitirle al usuario ver diferentes aplicaciones al mismo tiempo, a través de “ventanas” en
la pantalla. Esto necesita un soporte más sofisticado en el sistema operativo.

• Nuevos servicios: Como respuesta a Las demandas del usuario o a las necesidades de los administradores
del sistema, el sistema operativo ampliará su oferta de servicios. Por ejemplo, si se determina que es difícil
de mantener un buen rendimiento para los usuarios con las herramientas existentes, se deben añadir
nuevas medidas y herramientas de control al sistema operativo. Otro ejemplo es el de las nuevas
aplicaciones que exigen el uso de ventanas en la pantalla. Esta característica requiere actualizaciones
mayores en el sistema operativo.

• Correcciones: Desafortunadamente, el sistema operativo tiene fallos que se descubrirán con el curso
del tiempo y que es necesario corregir. Por supuesto, estas correcciones pueden introducir nuevos fallos
a su vez y así sucesivamente. La necesidad de hacer cambios en un sistema operativo de forma regular
introduce ciertos requisitos en el diseño. Una afirmación obvia es que el sistema debe tener una
construcción modular, con interfaces bien definidas entre los módulos y debe estar bien documentado.
Para programas grandes, como normalmente son los sistemas operativos actuales, no es adecuado lo que
podría denominarse modularización elemental [DENN80a]. Es decir, debe hacerse mucho más que dividir
simplemente un programa en subrutinas.
Evolución de los sistemas operativos
Proceso en serie
En los primeros computadores, de finales de los 40 hasta mediados de los 50, el programador interactuaba
directamente con el hardware; no había sistema operativo. La operación con estas máquinas se efectuaba
desde una consola consistente en unos indicadores luminosos, unos conmutadores, algún tipo de
dispositivo de entrada y una impresora. Los programas en código máquina se cargaban a través del
dispositivo de entrada (un lector de tarjetas, por ejemplo). Si se detiene el programa por un error, la
condición de error se indicaba mediante los indicadores luminosos. El programador podía examinar los
registros y la memoria principal para determinar la causa del error. Si el programa continuaba hasta su
culminación normal, la salida aparecería en la impresora.

Estos primeros sistemas presentaban dos problemas principales:

• Planificación: La mayoría de las instalaciones empleaban un formulario de reserva de tiempo de

máquina. Normalmente, un usuario podía reservar bloques de tiempo en múltiplos de media hora o algo
por el estilo. Un usuario podía reservar una hora y terminar a los 45 minutos; esto daba como resultado
un desperdicio del tiempo del computador. Por el contrario, el usuario podía tener dificultades, no
terminar en el tiempo asignado y verse forzado a parar sin haber solucionado el problema.

• Tiempo de preparación: Un programa sencillo, llamado trabajo, cargaba un compilador y un programa

en lenguaje de alto nivel (programa fuente) en la memoria, salvaba el programa compilado (programa
objeto) y luego montaba y cargaba el programa objeto junto con las funciones comunes. Cada uno de
estos pasos podía implicar montar y desmontar cintas o preparar paquetes de tarjetas. Si se producía un
error, el infortunado usuario tenía que volver al inicio de este proceso de preparación. De este modo, se
perdía un tiempo considerable en preparar un programa para su ejecución.

Este modo de operación podría denominarse proceso en serie porque refleja el hecho de que los usuarios
tenían que acceder al computador en serie. Con el paso del tiempo se desarrollaron varias herramientas
de software de sistemas para intentar hacer más eficiente este proceso en serie. Entre éstas se incluían
bibliotecas de funciones comunes, montadores, cargadores, depuradores y rutinas de manejo de E/S que
estaban disponibles como un software común para todos los usuarios.
Sistemas sencillos de proceso por lotes
Las primeras máquinas eran muy caras y, por tanto, era importante maximizar la utilización de estas. El
tiempo desperdiciado por la planificación y la preparación era inaceptable. Para mejorar el uso, se
desarrolló el concepto de sistema operativo por lotes (batch). El primer sistema operativo por lotes fue
desarrollado a mediados de los 50 por la General Motors para usar en un IBM 701 [WEIZ81]. Este concepto
fue refinado posteriormente e implementado en un IBM 704 por una serie de clientes de IBM. A principios
de los 60, un conjunto de constructores ya había desarrollado sistemas operativos por lotes para sus
computadores. IBSYS, el sistema operativo de IBM para los computadores 7090/7094, es particularmente
notable por su amplia influencia en otros sistemas. La idea central que está detrás del esquema sencillo
de proceso por lotes es el uso de un elemento de software conocido como monitor. Con el uso de esta
clase de sistema operativo, los usuarios ya no tenían acceso directo a la máquina. En su lugar, el usuario
debía entregar los trabajos en tarjetas o en cinta al operador del computador, quien agrupaba
secuencialmente los trabajos por lotes y ubicaba los lotes enteros en un dispositivo de entrada para su
empleo por parte del monitor. Cada programa se construía de modo tal que volviera al monitor al terminar
su procesamiento y, en ese momento, el monitor comenzaba a cargar automáticamente el siguiente
programa. Para entender cómo funciona este esquema, se va a ver desde dos puntos de vista: el del
monitor y el del procesador. Desde el punto de vista del monitor, él es quien controla la secuencia de
sucesos. Para que esto sea posible, gran parte del monitor debe estar siempre en memoria principal y
disponible para su ejecución (figura 2.3).

Considérese ahora esta secuencia desde el punto de vista del procesador. En un cierto momento, el
procesador estará ejecutando instrucciones de la zona de memoria principal que contiene al monitor.
Estas instrucciones hacen que el trabajo siguiente sea leído en otra zona de la memoria principal. Una vez
que el trabajo se ha leído, el procesador encuentra en el monitor una instrucción de desvío que ordena al
procesador continuar la ejecución en el inicio del programa de usuario. El procesador ejecuta entonces
las instrucciones del programa de usuario hasta que encuentre una condición de finalización o de error.
Cualquiera de estos dos sucesos provoca que el procesador vaya a por la instrucción siguiente del
programa monitor. De este modo, la frase "el control se le pasa al trabajo" quiere decir simplemente que
el procesador pasa a leer y ejecutar instrucciones del programa de usuario, mientras que la frase "el
control vuelve al monitor" quiere decir que el procesador pasa ahora a leer y ejecutar las instrucciones
del programa monitor. Debe quedar claro que es el monitor el que gestiona el problema de la
planificación. Se pone en cola un lote de trabajos y éstos son ejecutados tan rápido como es posible, sin
que haya tiempo alguno de desocupación. ¿Qué ocurre con la preparación de los trabajos? El monitor
también se encarga de esto. Con cada trabajo, se incluyen instrucciones de una forma primitiva de
lenguaje de control de trabajos (JCL, Job Control Lenguaje), que es un tipo especial de lenguaje de
programación empleado para dar instrucciones al monitor. La figura 2.4 muestra un ejemplo sencillo con
entrada de trabajos desde tarjetas. En este ejemplo, el usuario envía un programa escrito en FORTRAN
junto a unos datos que se utilizarán en el programa. Además de las tarjetas de FORTRAN y de datos, el
paquete incluye instrucciones de control de trabajos, que se denotan mediante un signo dólar ($) al
comienzo.

Para ejecutar el trabajo, el monitor lee la tarjeta $FTN y carga el compilador adecuado desde el dispositivo
de almacenamiento masivo (generalmente una cinta). El compilador traduce el programa de usuario en
código objeto, que se almacena en memoria o en el dispositivo de almacenamiento. Si se carga en
memoria, la operación es conocida como "compilar, cargar y arrancar" (compile, load, and go). Si se
almacena en cinta, entonces se requiere la tarjeta $LOAD. Esta tarjeta es leída por el monitor, quien
retoma el control después de la operación de compilación. El monitor llama al cargador, que carga el
programa objeto en memoria en el lugar del compilador y le transfiere el control. De esta manera, un
segmento grande de memoria se puede compartir entre diferentes subsistemas, aunque en cada
momento sólo uno de ellos tiene que estar presente y ejecutándose.
Sistemas por lotes con multiprogramación
Aún con el secuenciamiento automático de los trabajos ofrecido por un sistema operativo sencillo por
lotes, el procesador está desocupado a menudo. El problema es que los dispositivos de E/S son lentos
comparados con el procesador. La figura 2.5 detalla un cálculo representativo. Los números corresponden
a un programa que procesa un archivo de registros y ejecuta, en promedio, 100 instrucciones de máquina
por cada registro. En este ejemplo, el computador gasta más del 96% del tiempo esperando a que los
dispositivos de E/S terminen de transferir sus datos. La figura 2.6a ilustra esta situación. El procesador
gasta parte del tiempo ejecutando hasta que encuentra una instrucción de E/S. Entonces debe esperar a
que concluya la instrucción de E/S antes de continuar.

Esta ineficiencia no es necesaria. Se sabe que hay memoria suficiente para almacenar el sistema operativo
(el monitor residente) y un programa de usuario. Supóngase que hay espacio suficiente para el sistema
operativo y dos programas usuarios. Ahora, cuando un trabajo necesite esperar una E/S, el procesador
puede cambiar al otro trabajo, que probablemente no estará esperando a la E/S (figura 2.6b). Además, se
podría ampliar la memoria para almacenar tres, cuatro o más programas y conmutar entre todos ellos
(figura 2.6c). Este proceso es conocido como multiprogramador o multitarea. Éste es el punto central de
los sistemas operativos modernos.

Sistemas de tiempo compartido

Con el uso de la multiprogramación, el tratamiento por lotes puede llegar a ser bastante eficiente. Sin
embargo, para muchas tareas, es conveniente suministrar un modo en que el usuario interactúe
directamente con el computador. De hecho, para algunos trabajos, tales como el proceso de
transacciones, este modo interactivo es fundamental. Hoy en día, los requisitos de un servicio de
computación interactiva pueden y suelen llevarse a cabo con el empleo de un computador dedicada. Esta
opción no estaba disponible en los años 60, cuando la mayoría de los computadores eran grandes y
costosas. En su lugar, se desarrollaron las técnicas de tiempo compartido.

Al igual que la multiprogramación permite al procesador manejar varias tareas por lotes al mismo tiempo,
la multiprogramación puede también utilizarse para manejar varias tareas interactivas. En este último
caso, la técnica se conoce como tiempo compartido, porque refleja el hecho de que el tiempo del
procesador es compartido entre los diversos usuarios. La técnica básica de un sistema de tiempo
compartido es tener a varios usuarios utilizando simultáneamente el sistema mediante terminales,
mientras que el sistema operativo intercala la ejecución de cada programa de usuario en ráfagas cortas
de cómputo o cuantos (quantum). De esta manera, si hay n usuarios que solicitan servicio a la vez, cada
usuario sólo dispondrá, en promedio, de Un de la atención efectiva del computador, sin contar con la
sobrecarga del sistema operativo. Sin embargo, dado el tiempo de reacción relativamente lento que tiene
el ser humano, el tiempo de respuesta en un sistema correctamente diseñado debería ser comparable al
de un computador dedicada.
Conclusión.
En mi opinión es importante saber y conocer los antecedentes históricos acerca del desarrollo de los
sistemas operativos junto con el del hardware y su representativa evolución en las últimas décadas, ya
que así podremos comprender gran parte del funcionamiento de nuestros equipos. Además, resaltar la
importancia de los sistemas operativos y como este software base facilita la interacción entre la
computadora y el usuario. El sistema operativo es un conjunto de programas escritos con el fin de
administrar los recursos del hardware en el sistema. Si imagináramos un mundo donde el desarrollo de
los sistemas operativos no hubiera emergido, podríamos imaginar un mundo diferente sin computadoras
tan fáciles de manejar o incluso teléfonos inteligentes. En base a los acontecimientos, podemos
determinar que los sistemas operativos irán con el paso del tiempo evolucionando, junto con el hardware
en las computadoras para seguirnos facilitando tareas para nosotros los usuarios.

Bibliografía
Stallings, W. (1997). Sistemas Operativos, Segunda Edición. Madrid: Prentice Hall.