UNIVERSIDAD NACIONAL PEDRO RUIZ GALLO

FACULTAD DE INGENIERÍA CIVIL, SISTEMAS Y ARQUITECTURA

Taller de computación e informática básica – grupo B

Alumno:

 FRANCO CHUGDÉN, Jorge Miguel

Docente:

 OLAVARRIA PAZ, Jesús

Lambayeque, septiembre del 2017

 SISTEMAS OPERATIVOS

¿Qué es un sistema operativo?

El sistema operativo es el principal programa que se ejecuta en toda computadora de

propósito general.

Los hay de todo tipo, desde muy simples hasta terriblemente complejos, y entre más
casos de uso hay para el cómputo en la vida diaria, más variedad habrá en ellos.

Un sistema operativo es un programa, o conjunto de programas que torna amigable,

eficiente y productivo el uso de un computador (hardware), permitiendo la ejecución
aplicaciones de usuario. Es el intermediario entre las aplicaciones de usuario y el
hardware.

Metas:

• Brindar un ambiente de realización y ejecución de aplicaciones

• Proveer un entorno sin interferencias a cada usuario (interferencia: Lo que un

usuario modifica en su entorno, no interfiera ni modifique lo de otro usuario)

• Administrar en forma equitativa los recursos (hardware y software)

• Hacerlo de la forma más amigable e intuitiva posible Todas las aplicaciones de

usuario requieren un conjunto común de operaciones que son incorporadas al
sistema operativo.

Tareas principales:

• Implementar diferentes entornos para diferentes usos (interfaz gráfica, shells,

tipo web, etc)

• Proveer una o más interfaces con el usuario.

• Proveer a las aplicaciones un conjunto de servicios (a través de los “system

services”)

• Eficiencia y equidad en la administración de recursos.

Se Puede decir que el Sistema operativo es un:

 • Administrador de recursos. Su tarea consiste en administrar los recursos
disponibles y decidir como asignar estos recursos según los pedidos y
asignaciones que tenga.

• Programa de Control: Controla la ejecución de los programas para la prevención

de errores y mal uso del sistema. Frecuentemente la porción residente (el código
incambiable. Cuanto más código incambiable, más inflexible es) del propio
sistema operativo se denomina núcleo del sistema (Kernel).

HISTORIA DE LOS SISTEMAS OPERATIVOS

Todo empezó en la década de los 40.

AÑOS 40

A finales de los años 1940, con lo que podríamos llamar la aparición de la primera
generación de computadoras, se accedía directamente a la consola de la computadora
desde la cual se actuaba sobre una serie de micro interruptores que permitían introducir
directamente el programa en la memoria de la computadora (en realidad al existir tan
pocas computadoras todos podrían considerarse prototipos y cada constructor lo hacía
sin seguir ningún criterio predeterminado). Por aquel entonces no existían los sistemas
operativos, y los programadores debían interactuar con el hardware del computador sin
ayuda externa. Esto hacía que el tiempo de preparación para realizar una tarea fuera
considerable. Además, para poder utilizar la computadora debía hacerse por turnos. Para
ello, en muchas instalaciones, se rellenaba un formulario de reserva en el que se
indicaba el tiempo que el programador necesitaba para realizar su trabajo. En aquel
entonces las computadoras eran máquinas muy costosas lo que hacía que estuvieran
muy solicitadas y que sólo pudieran utilizarse en periodos breves de tiempo. Todo se
hacía en lenguaje de máquina.
AÑOS 50 (Sistema Batch)

A principios de los años 50 con el objeto de facilitar la interacción entre persona y

computador, los sistemas operativos hacen una aparición discreta y bastante simple, con
conceptos tales como el monitor residente, el proceso por lotes y el almacenamiento
temporal.

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.

Monitor residente

Su funcionamiento era bastante simple, se limitaba a cargar los programas a memoria,

leyéndolos de una cinta o de tarjetas perforadas, y ejecutarlos. El problema era
encontrar una forma de optimizar el tiempo entre la retirada de un trabajo y el montaje
del siguiente.

Procesamiento por lotes

Como solución para optimizar el tiempo de montaje surgió la idea de agrupar los
trabajos en lotes, en una misma cinta o conjunto de tarjetas, de forma que se ejecutaran
uno a continuación de otro sin perder apenas tiempo en la transición.

Las primeras máquinas eran muy caras y, por tanto, era importante maximizar la
utilización de las mismas. 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 las computadoras
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). Esta parte del
monitor se conoce como monitor residente. El resto del monitor consta de utilidades y
funciones comunes que se cargan como subrutinas en los programas de los usuarios al
comienzo de cualquier trabajo que las necesite. El monitor lee los trabajos uno a uno del
dispositivo de entrada (normalmente, un lector de tarjetas o una unidad de cinta
magnética). A medida que lo lee, el trabajo actual se ubica en la zona del programa de
usuario y el control pasa al trabajo. Cuando el trabajo termina, se devuelve el control al
monitor, quien lee inmediatamente un nuevo trabajo. Los resultados de cada trabajo se
imprimen y entregan al usuario.

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.

Durante la ejecución del programa de usuario, cada instrucción de entrada origina la

lectura de una tarjeta de datos. La instrucción de entrada en el programa del usuario
hace que se invoque una rutina de entrada, que forma parte del sistema operativo. La
rutina de entrada se asegura de que el programa de usuario no ha leído accidentalmente
una tarjeta JCL. Si esto sucede, se produce un error y el control se transfiere al monitor.
Al terminar un trabajo, con o sin éxito, el monitor recorre las tarjetas de entrada hasta
encontrar la próxima tarjeta JCL. De este modo, el sistema se protege contra un
programa que tenga tarjetas de datos de más o de menos.

Se comprobará que el monitor o el sistema de proceso por lotes es simplemente un

programa de computador. Se basa en la capacidad del procesador para traer y ejecutar
instrucciones desde varias zonas de la memoria principal y así apoderarse y ceder el
control de forma alterna. Para esto serian convenientes algunas otras características del
hardware, entre las que se encuentran las siguientes:
• Protección de memoria: Mientras el programa de usuario esté ejecutándose, no debe
modificar la zona de memoria en la que está el monitor. Si se hace un intento tal, el
hardware del procesador deberá detectar el error y transferir el control al monitor. El
monitor abortará entonces el trabajo, imprimirá el mensaje de error y cargará el
siguiente trabajo.

• Temporizador: Se utiliza un temporizador para impedir que un sólo trabajo

monopolice el sistema. El temporizador se lanza al comenzar cada trabajo. Si expira el
tiempo, se producirá una interrupción y el control volverá al monitor.

• Instrucciones Privilegiadas: Ciertas instrucciones son designadas como privilegiadas y

pueden ser ejecutadas solo por el monitor. Si el procesador encuentra una instrucción
tal, cuando está ejecutando el programa del usuario, se producirá una interrupción de
error. Entre las instrucciones privilegiadas se encuentran las instrucciones de E/S, de
forma que el monitor retenga el control de todos los dispositivos de E/S. Esto impide,
por ejemplo, que un programa de usuario lea accidentalmente instrucciones de control
que son del trabajo siguiente. Si un programa de usuario desea realizar una E/S, debe
solicitarse al monitor que haga la operación por él. Si el procesador encuentra una
instrucción privilegiada cuando está ejecutando un programa de usuario, el hardware del
procesador la considera como un error y transfiere el control al monitor.

• Interrupciones: Los primeros modelos de computadores no tenían esta capacidad. Esta

característica aporta al sistema operativo más flexibilidad para ceder y retomar el
control de los programas usuarios.

Naturalmente, se puede construir un sistema operativo sin estas características, pero los
fabricantes de computadores comprobaron rápidamente que los resultados eran caóticos
y, por tanto, incluso los sistemas operativos por lotes más primitivos ya disponían de
estas características en el hardware. Por otro lado, hay que decir que el sistema
operativo más utilizado del mundo, el PC-DOS/MS-DOS, no dispone de protección de
memoria ni de instrucciones privilegiadas de E/S. Sin embargo, como este sistema está
destinado a computadores personales de un solo usuario, los problemas que se pueden
originar son menos graves.

En un sistema operativo por lotes, el tiempo de máquina se reparte entre la ejecución de

programas de usuario y la ejecución del monitor. Así se tienen dos pérdidas: se entrega
al monitor cierta cantidad de memoria principal y éste consume cierto tiempo de la
máquina. Ambas pérdidas son una forma de sobrecarga. Aún con esta sobrecarga, los
sistemas operativos sencillos por lotes mejoran el uso del computador.

Almacenamiento temporal

Su objetivo era disminuir el tiempo de carga de los programas, haciendo simultánea la

carga del programa o la salida de datos con la ejecución de la siguiente tarea. Para ello
se utilizaban dos técnicas, el buffering y el spooling.

La década de 1960

En los años 60 se produjeron cambios notorios en varios campos de la informática, con la

aparición del circuito integrado la mayoría orientados a seguir incrementando el potencial de los
ordenadores. Para ello se utilizaban técnicas de lo más diversas.

Los Sistemas multiprogramados

A lo largo de su ejecución, un programa normalmente pasa por etapas con muy distintas
características: durante un ciclo fuertemente dedicado al cálculo numérico, el sistema
opera limitado por el CPU (CPU-bound), mientras que al leer o escribir resultados a
medios externos (incluso mediante spools) el límite es impuesto por los dispositivos,
esto es, opera limitado por entrada-salida (I-O bound). La programación multitareas o
los sistemas multiprogramados buscaban maximizar el tiempo de uso efectivo del
procesador ejecutando varios procesos al mismo tiempo. El hardware requerido cambió
fuertemente. Si bien se esperaba que cada usuario fuera responsable con el uso de
recursos, resultó necesario que apareciera la infraestructura de protección de recursos:
un proceso no debe sobrescribir el espacio de memoria de otro (ni el código, ni los
datos), mucho menos el espacio del monitor. Esta protección se encuentra en la Unidad
de Manejo de Memoria (MMU), presente en todas las computadoras de uso genérico
desde los años noventa. Ciertos dispositivos requieren bloqueo para ofrecer acceso
exclusivo/único: cintas e impresoras, por ejemplo, son de acceso estrictamente
secuencial, y si dos usuarios intentaran usarlas al mismo tiempo, el resultado para
ambos se corrompería. Para estos dispositivos, el sistema debe implementar otros spools
y mecanismos de bloqueo.
Sistemas de tiempo compartido El modo de interactuar con las computadoras se
modificó drásticamente durante los años sesenta, al extenderse la multitarea para
convertirse en sistemas interactivos y multiusuarios, en buena medida diferenciados de
los anteriores por la aparición de las terminales (primero teletipos seriales,
posteriormente equipos con una pantalla completa como se conocen hasta hoy). En
primer término, la tarea de programación y depuración del código se simplificó
fuertemente al poder hacer el programador directamente cambios y someter el programa
a la ejecución inmediata. En segundo término, la computadora nunca más estaría
simplemente esperando a que esté listo un programa: mientras un programador editaba o
compilaba su programa, la computadora seguía calculando lo que otros procesos
requirieran. Un cambio fundamental entre el modelo de multiprogramación y de tiempo
compartido es el tipo de control sobre la multitarea (se verá en detalle en el capítulo 3).
Multitarea cooperativa o no apropiativa (Cooperative multitasking). La implementaron
los sistemas multiprogramados: cada proceso tenía control del CPU hasta que éste hacía
una llamada al sistema (o indicara su disposición a cooperar por medio de la llamada
yield: ceder el paso). Un cálculo largo no era interrumpido por el sistema operativo, en
consecuencia, un error de programador podía congelar la computadora completa.
Multitarea preventiva o apropiativa (Preemptive multitasking). En los sistemas de
tiempo compartido, el reloj del sistema interrumpe periódicamente a los diversos
procesos, transfiriendo forzosamente el control nuevamente al sistema operativo. Éste
puede entonces elegir otro proceso para continuar la ejecución. Además, fueron
naciendo de forma natural y paulatina las abstracciones que se conocen hoy en día,
como los conceptos de archivos y directorios, y el có- digo necesario para emplearlos
iba siendo enviado a las bibliotecas de sistema y, cada vez más (por su centralidad)
hacia el núcleo mismo del, ahora sí, sistema operativo. Un cambio importante entre los
sistemas multiprogramados y de tiempo compartido es que la velocidad del cambio
entre una tarea y otra es mucho más rápido: si bien en un sistema multiprogramado un
cambio de contexto podía producirse sólo cuando la tarea cambiaba de un modo de
ejecución a otro, en un sistema interactivo, para dar la ilusión de uso exclusivo de la
computadora, el hardware emitía periódicamente al sistema operativo interrupciones
(señales) que le indicaban que cambie el proceso activo (como ahora se le denomina a
una instancia de un programa en ejecución). Diferentes tipos de proceso pueden tener
distinto nivel de importancia —ya sea porque son más relevantes para el
funcionamiento de la computadora misma (procesos de sistema), porque tienen mayor
carga de interactividad (por la experiencia del usuario) o por diversas categorías de
usuarios (sistemas con contabilidad por tipo de atención). Esto requiere la
implementación de diversas prioridades para cada uno de éstos.

Tiempo Real

Estos sistemas se usan en entornos donde se deben aceptar y procesar en tiempos muy
breves un gran número de sucesos, en su mayoría externos al ordenador. Si el sistema
no respeta las restricciones de tiempo en las que las operaciones deben entregar su
resultado se dice que ha fallado. El tiempo de respuesta a su vez debe servir para
resolver el problema o hecho planteado. El procesamiento de archivos se hace de una
forma continua, pues se procesa el archivo antes de que, entre el siguiente, sus primeros
usos fueron y siguen siendo en telecomunicaciones.

Multiprocesador

Permite trabajar con máquinas que poseen más de un microprocesador. En un

multiprocesador los procesadores comparten memoria y reloj.

Sistemas Operativos Desarrollados

Además del Atlas Supervisor y el OS/360, los sesenta marcaron el inicio de UNIX, a
mediados de los 60 aparece Multics, sistema operativo multiusuario – multitarea
desarrollado por los laboratorios Bell de AT&T y programado en PL/1 uno de los pocos
SO desarrollados en un lenguaje de alto nivel en aquel tiempo, luego del fracaso del
proyecto UNIX comienza a desarrollarse a partir de este a finales de la década.

AÑOS 70

Debido al avance de la electrónica, pudieron empezar a crearse circuitos con miles de

transistores en un centímetro cuadrado de silicio, lo que llevaría, pocos años después, a
producirse los primeros sistemas integrados. Ésta década se podría definir como la de
los sistemas de propósito general y en ella se desarrollan tecnologías que se siguen
utilizando en la actualidad. Es en los años 1970 cuando se produce el boom de los
miniordenadores y la informática se acerca al nivel de usuario. En lo relativo a
lenguajes de programación, es de señalar la aparición de Pascal y C, el último de los
cuales se creó específicamente para reescribir por completo el código del sistema
operativo Unix, convirtiéndolo en uno de los pocos SO escritos en un lenguaje de alto
nivel. En el campo de la programación lógica se dio a luz la primera implementación de
Prolog, y en la revolucionaria orientación a objetos, Smalltalk.

Inconvenientes De Los Sistemas Existentes

Se trataba de sistemas grandes y costosos, pues antes no se había construido nada

similar y muchos de los proyectos desarrollados terminaron con costos muy por encima
del presupuesto y mucho después de lo que se marcaba como fecha de finalización.
Además, aunque formaban una capa entre el hardware y el usuario, éste debía conocer
un complejo lenguaje de control para realizar sus trabajos. Otro de los inconvenientes es
el gran consumo de recursos que ocasionaban, debido a los grandes espacios de
memoria principal y secundaria ocupados, así como el tiempo de procesador
consumido. Es por esto que se intentó hacer hincapié en mejorar las técnicas ya
existentes de multiprogramación y tiempo compartido.

Características De Los Nuevos Sistemas

Para solventar los problemas antes comentados, se realizó un costosísimo trabajo para
interponer una amplia capa de software entre el usuario y la máquina, de forma que el
primero no tuviese que conocer ningún detalle de la circuitería.

Sistemas operativos desarrollados

* MULTICS (Multiplexed Information and Computing Service): Originalmente era un

proyecto cooperativo liderado por Fernando Corbató del MIT, con General Electric y
los laboratorios Bell, que comenzó en los 60, pero los laboratorios Bell abandonaron en
1969 para comenzar a crear el sistema UNIX. Se desarrolló inicialmente para el
mainframe GE-645, un sistema de 36 bits; después fue soportado por la serie de
máquinas Honeywell 6180.

Fue uno de los primeros sistemas operativos de tiempo compartido, que implementó un
solo nivel de almacenamiento para el acceso a los datos, desechando la clara distinción
entre los ficheros y los procesos en memoria, y uno de los primeros sistemas
multiprocesador.
* MVS (Multiple Virtual Storage): Fue el sistema operativo más usado en los modelos
de mainframes -ordenadores grandes, potentes y caros usados principalmente por
grandes compañías para el procesamiento de grandes cantidades de datos- System/370 y
System/390 de IBM, desarrollado también por IBM y lanzado al mercado por primera
vez en 1974. Como características destacables, permitía la ejecución de múltiples tareas,
además de que introdujo el concepto de memoria virtual y finalmente añadió la
capacidad de que cada programa tuviera su propio espacio de direccionamiento de
memoria, de ahí su nombre.

* CP/M (Control Program/Monitor): Desarrollado por Gary Kildall para el

microprocesador 8080/85 de Intel y el Zilog Z80, salió al mercado en 1976,
distribuyéndose en disquetes de ocho pulgadas. Fue el SO más usado en las
computadoras personales de esta década. Su éxito se debió a que era portátil,
permitiendo que diferentes programas interactuasen con el hardware de una manera
estandarizada. Estaba compuesto de dos subsistemas:


CCP (Comand Control Processor): Intérprete de comandos que permitía
introducir los mandatos con sus parámetros separados por espacios. Además, los
traducía a instrucciones de alto nivel destinadas a BDOS.

BDOS (Basic Disk Operating System): Traductor de las instrucciones en
llamadas a la BIOS.

El hecho de que, años después, IBM eligiera para sus PCs a MS-DOS supuso su mayor
fracaso, por lo que acabó desapareciendo.

AÑOS 80

Con la creación de los circuitos LSI -integración a gran escala-, chips que contenían
miles de transistores en un centímetro cuadrado de silicio, empezó el auge de los
ordenadores personales. En éstos se dejó un poco de lado el rendimiento y se buscó más
que el sistema operativo fuera amigable, surgiendo menús, e interfaces gráficas. Esto
reducía la rapidez de las aplicaciones, pero se volvían más prácticos y simples para los
usuarios. En esta época, siguieron utilizándose lenguajes ya existentes, como Smalltalk
o C, y nacieron otros nuevos, de los cuales se podrían destacar: C++ y Eiffel dentro del
paradigma de la orientación a objetos, y Haskell y Miranda en el campo de la
programación declarativa. Un avance importante que se estableció a mediados de la
década de 1980 fue el desarrollo de redes de computadoras personales que corrían
sistemas operativos en red y sistemas operativos distribuidos. En esta escena, dos
sistemas operativos eran los mayoritarios: MS-DOS, escrito por Microsoft para IBM PC
y otras computadoras que utilizaban la CPU Intel 8088 y sus sucesores, y UNIX, que
dominaba en los ordenadores personales que hacían uso del Motorola 68000.

Apple Macintosh

El lanzamiento oficial se produjo en enero de 1984, al precio de 2495 dólares. Muchos

usuarios, al ver que estaba completamente diseñado para funcionar a través de una GUI
(Graphic User Interface), acostumbrados a la línea de comandos, lo tacharon de juguete.
A pesar de todo, el Mac se situó a la cabeza en el mundo de la edición a nivel gráfico.

MS-DOS

En 1981 Microsoft compró un sistema operativo llamado QDOS que, tras realizar unas
pocas modificaciones, se convirtió en la primera versión de MS-DOS (MicroSoft Disk
Operating System). A partir de aquí se sucedieron una serie de cambios hasta llegar a la
versión 7.1, a partir de la cual MS-DOS dejó de existir como tal y se convirtió en una
parte integrada del sistema operativo Windows.

Microsoft Windows
Familia de sistemas operativos propietarios desarrollados por la empresa de software
Microsoft Corporation, fundada por Bill Gates y Paul Allen. Todos ellos tienen en
común el estar basados en una interfaz gráfica de usuario basada en el paradigma de
ventanas, de ahí su nombre en inglés. Las versiones de Windows que han aparecido
hasta el momento se basan en dos líneas separadas de desarrollo que finalmente
convergen en una sola con la llegada de Windows XP. La primera de ellas conformaba
la apariencia de un sistema operativo, aunque realmente se ejecutaba sobre MS-DOS.

Actualmente existe Windows Vista.

AÑOS 90

GNU/Linux

En 1991 aparece la primer versión del núcleo de Linux. Creado por Linus Torvalds y
un sinfín de colaboradores a través de Internet. Este sistema se basa en Unix, un sistema
que en principio trabajaba en modo comandos, estilo MS-DOS. Hoy en día dispone de
Ventanas, gracias a un servidor grafico y a gestores de ventanas como KDE, GNOME
entre muchos. Recientemente GNU/Linux dispone de un aplicativo que convierte las
ventanas en un entorno 3D como por ejemplo Beryl. Lo que permite utilizar linux de
una forma muy visual y atractiva.

BeOS

BeOS es un sistema operativo para PC desarrollado por Be Incorporated en 1990,

orientado principalmente a proveer alto rendimiento en aplicaciones multimedia. A
pesar de la creencia común fomentada por la inclusión de la interfaz de comandos Bash
en el sistema operativo, el diseño de BeOS no estaba basado en UNIX.

Originalmente (1995-1996) el sistema operativo se corría sobre su propio hardware,

conocido como BeBox. Más tarde (1997) fue extendido a la plataforma PowerPC y
finalmente (1998) se añadió compatibilidad con procesadores x86.
Solaris

Solaris es un sistema operativo de tipo Unix desarrollado desde 1992 inicialmente por
Sun Microsystems y actualmente por Oracle Corporation como sucesor de SunOS. Es
un sistema certificado oficialmente como versión de Unix. Funciona en arquitecturas
SPARC y x86 para servidores y estaciones de trabajo.

ReactOS

ReactOS (React Operating System) es un sistema operativo de código abierto destinado

a lograr la compatibilidad binaria con aplicaciones de software y controladores de
dispositivos hechos para Microsoft Windows NT versiones 5.x en adelante (Windows
XP y sus sucesores).

En 1996 un grupo de programadores y desarrolladores de software libre comenzaron un

proyecto llamado FreeWin95 el cual consistía en implementar un clon de Windows 95.
El proyecto estuvo bajo discusión por el diseño del sistema ya habiendo desarrollado la
capa compatible con MS-DOS, pero lamentablemente esta fue una situación que no se
completó. Para 1997 el proyecto no había lanzado ninguna versión, por lo que los
miembros de éste, coordinados por Jason Filby, pudieron revivirlo. Se decidió cambiar
el núcleo del sistema compatible con MS-DOS y de ahora en adelante basarlo en uno
compatible con Windows NT, y así el proyecto pudo seguir adelante con el nombre
actual de ReactOS, que comenzó en febrero de 1998, desarrollando las bases del kernel
y algunos drivers básicos.

FreeDOS

FreeDOS es un proyecto que aspira a crear un sistema operativo libre que sea totalmente
compatible con las aplicaciones y los controladores de MS-DOS.

El programa ya ha alcanzado un alto grado de madurez y tiene algunas características

que no existían en MS-DOS. Algunos comandos de FreeDOS son idénticos o mejores
que sus equivalentes de MS-DOS, pero aún faltan algunos del sistema operativo
original.
El intérprete de línea de comandos usado por FreeDOS se llama FreeCOM.

La década de 2000

SymbOS

SymbOS es un sistema operativo desarrollado originalmente en 2001 para los

ordenadores Amstrad CPC. Se trata de un sistema operativo gráfico con una estética e
interfaz similar a Windows 95. A pesar de la baja potencia que desarrollan estos
ordenadores, alrededor de 4MHz, está minuciosamente optimizado para el hardware en
el cuál funciona, por lo que el rendimiento es más que aceptable.

Debido a su cuidada programación modular, ha sido migrado posteriormente a los

ordenadores MSX, Amstrad PCW y Enterprise 128 que, con versiones adaptadas y
recompiladas en cada caso, son capaces de ejecutar las mismas aplicaciones sin
modificación alguna.

Aunque parezca un sistema obsoleto, existe una extensa comunidad implicada en el

proyecto. Los programadores originales continúan actualizando y dando soporte al
sistema en la actualidad.

SymbOS es un claro ejemplo de software optimizado, de tal manera que con un mínimo
hardware se obtienen prestaciones similares a otros grandes sistemas operativos
actuales. Esto lo convierte en el antagonista de los modernos sistemas operativos, que
derrochan la mayor parte de los recursos apoyándose en la alta potencia del hardware
actual.

MorphOS

MorphOS es un sistema operativo, en parte propietario y en parte de código abierto,

producido para ordenadores basados en los procesadores PowerPC (PPC). El sistema
operativo en sí es propietario, pero muchas de sus bibliotecas y otros componentes son
de código abierto, como Ambient (la interfaz del escritorio). La mariposa azul es el logo
característico de este sistema operativo. Está basado en el Micronúcleo de Quark.

Darwin

Darwin es el sistema que subyace en Mac OS X, cuya primera versión final salió en el
año 2001 para funcionar en computadoras Macintosh.

Integra el micronúcleo XNU y servicios de sistema operativo de tipo UNIX basados

en BSD 4.4 (en particular FreeBSD) que proporcionan una estabilidad y un rendimiento
mayor que el de versiones anteriores de Mac OS. Se trata de una evolución del sistema
operativo NEXTSTEP (basado en Mach 2.5 y código BSD 4.3) desarrollado
por NeXT en 1989comprado por Apple Computer en diciembre de 1996.

Darwin proporciona al Mac OS X prestaciones modernas, como la memoria protegida,

la multitarea por desalojo o expulsiva, la gestión avanzada de memoria y
el multiprocesosimétrico.

MAC OS

Mac OS, antes llamado Mac OS X, es un sistema operativo basado en Unix,

desarrollado, comercializado y vendido por Apple Inc.

La primera versión del sistema fue Mac OS X Server 1.0 en 1999, y en cuanto al
escritorio, fue Mac OS X v10.0 «Cheetah» (publicada el 24 de marzo de 2001).

La variante para servidores, Mac OS X Server, es arquitectónicamente idéntica a su

contraparte para escritorio, además de incluir herramientas para administrar grupos de
trabajo y proveer acceso a los servicios de red. Estas herramientas incluyen un servidor
de correo, un servidor Samba, un servidor LDAP y un servidor de dominio entre otros.
Haiku

Haiku es un sistema operativo de código abierto actualmente en desarrollo que se centra

específicamente en la informática personal y multimedia. Inspirado por BeOS (Be
Operating System), Haiku aspira a convertirse en un sistema rápido, eficiente, fácil de
usar y fácil de aprender, sin descuidar su potencia para los usuarios de todos los niveles.

OpenSolaris

OpenSolaris fue un sistema operativo libre publicado en 2005 a partir de la versión

privativa de Solaris de Sun Microsystems, ahora parte de Oracle Corporation.
OpenSolaris es también el nombre de un proyecto iniciado en 2005 por Sun para
construir y desarrollar una comunidad de usuarios alrededor de las tecnologías del
sistema operativo del mismo nombre. Después de la adquisición de Sun Microsystems,
en agosto de 2010, Oracle decidió interrumpir la publicación y distribución de
OpenSolaris, así como su modelo de desarrollo, basado en la disponibilidad de
versiones de desarrollo compiladas cada dos semanas y versiones estables cada seis
meses. Sin embargo, los términos de su licencia libre no han sido modificados, por lo
que el código fuente afectado por ella será publicado cuando Oracle publique nuevas
versiones de Solaris.

La década de 2017

IllumOS

Illumos es un proyecto de software libre derivado de OpenSolaris. Fue anunciado por

conferencia web desde Nueva York el 3 de agosto de 2010. El nombre del proyecto es
un neologismo procedente del latín "Illum" (la luz) y de "OS" (operating system,
sistema operativo).

Se trata del código base a partir del cual cualquiera podrá crear su propia distribución de
software basada en el sistema operativo OpenSolaris. Pero Illumos no es una
distribución, ni una bifurcación (fork), al menos por el momento, en la medida que no
pretende separarse del tronco principal, sino un derivado de la "consolidación" OS/Net
(más conocida como ON), que consiste básicamente en el código fuente del kernel
(SunOS), los drivers, los servicios de red, las bibliotecas del sistema y los comandos
básicos del sistema operativo.

OpenIndiana

OpenIndiana Es un sistema operativo tipo Unix liberado como software libre y de

código abierto. Es una bifurcación de OpenSolaris concebida después de la compra de
Sun Microsystems por parte de Oracle y tiene como objetivo continuar con el desarrollo
y la distribución del código base de OpenSolaris. El proyecto opera bajo el patrocinio de
la Illumos Foundation (Fundación Illumos). El objetivo declarado del proyecto es
convertirse en la distribución de OpenSolaris de facto instalada en servidores de
producción donde se requieren soluciones de seguridad y errores de forma gratuita.

ESTRUCTURA DEL SISTEMA OPERATIVO

Las estructuras internas de los sistemas operativos pueden ser muy diferentes, ya que se
deben tener en cuenta las metas de los usuarios (fácil uso, confiable, rápido, etc.) y las
del sistema (fácil de diseñar, implementar y mantener, eficiente, etc.). Veremos 3
posibles diseños del sistema.

• Sistema Monolítico

Estos sistemas no tienen una estructura definida, sino que son escritos como una
colección de procedimientos donde cualquier procedimiento puede invocar a otro.
Ejemplos de estos sistemas pueden ser MS-DOS o Linux (aunque incluye algo de
capas). Es importante tener en cuenta que ningún sistema es puramente de un tipo.

• Sistema en capas

El diseño se organiza en una jerarquía de capas, donde los servicios que brinda una capa
son consumidos solamente por la capa superior. La capa 0 es del Hardware y la N es la
de los procesos de Usuario.
 Estos sistemas tienen como ventaja que son
modulares y la verificación se puede hacer a
cada capa por separado (son más
mantenibles). Sin embargo, el diseño es muy
costoso y es menos eficiente que el sistema
monolítico ya que pierde tiempo pasando por
cada capa.

• Sistema con micronúcleo

La idea consiste en tener un núcleo que brinde los servicios mínimos de manejo de
procesos, memoria y que provea la comunicación entre procesos. Todos los restantes
servicios se construyen como procesos separados del micronúcleo, que ejecutan en
modo usuario. Estos sistemas tienen como ventaja un diseño simple y funcional, que
aumenta la portabilidad y la escalabilidad. Para agregar un nuevo servicio no es
necesario modificar el núcleo, y es más seguro ya que los servicios corren en modo
usuario.