Practica num Aleatorios y procesos

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define lectura 0
#define escritura 1


int aleatorio(void)
{
int semilla = (int)time(NULL);
srand(semilla);
}

int hijo(int tube1[2], int tube2[2]){
int ret;
int minumero;

int numbytes;
char buf[256]={};

ret = fork();

if (ret == 0){
/*Tratamiento del nieto*/
//minumero = aleatorio();
minumero= 10;

printf("%d\n",minumero);
sprintf(buf,"%d",minumero);

if( write (tube1[escritura],buf, sizeof(buf)) == -1){
perror("Fallo write nieto");
exit(EXIT_FAILURE);
}

numbytes = read(tube2[lectura],buf,sizeof(buf));

if (numbytes == -1){
perror("Fallo read nieto");
exit(EXIT_FAILURE);
}



close(tube1[escritura]);
close(tube2[lectura]);

printf("Soy hijo2 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);


}

else if (ret > 0){
/*Tratamiento del padre*/

//minumero = aleatorio();
minumero=32;

printf("%d\n",minumero);
sprintf(buf,"%d",minumero);

if( write (tube2[escritura],buf, sizeof(buf)) == -1){
perror("Fallo write padre");
exit(EXIT_FAILURE);
}

numbytes = read(tube1[lectura],buf,sizeof(buf));

if (numbytes == -1){
perror("Fallo read padre");
exit(EXIT_FAILURE);
}




close(tube1[lectura]);
close(tube2[escritura]);

printf("Soy hijo1 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);
}

else if (ret == -1){
/*Error*/
perror("Fallo en el segundo fork");
exit(EXIT_FAILURE);
}
}

int main (void){
int ret;
int ret2;
int tube1[2];
int tube2[2];
int temp;
int e;
char buf[256]={};

if (pipe(tube1) == -1){
perror("Fallo pipe1");
exit(EXIT_FAILURE);
}

if (pipe(tube2) == -1){
perror("Fallo pipe2");
exit(EXIT_FAILURE);
}

ret = fork();

if (ret == 0){
/*tratamiento del hijo*/
hijo(tube1,tube2);

}

else if( ret > 0){
/*tratamiento del abuelo*/


}

else if (ret == -1){
/*error*/
perror("Fallo en fork");
exit(EXIT_FAILURE);
}

ret = wait (NULL);

while (ret > 0){
ret = wait(NULL);
}

if (ret == -1 && errno != ECHILD){
perror("Fallo en wait");
exit (EXIT_FAILURE);
}

}

Numero

escojo el numero 10

Posix

¿Que son?

El POSIX es un grupo de estándares en evolución. Cada uno de los estándares que lo

componen cubre diferentes aspectos de los sistemas operativos. Algunos de ellos ya han

sido aprobados, mientras que otros están aún en fase de desarrollo. Los estándares POSIX

se pueden agrupar en tres categorías diferentes

1) Estándares Base: Definen interfases del sistema relacionadas con diferentes

Tabla I. Lista de estándares base del POSIX

POSIX.1 Interfases del sistema (estándar básico)

a,b

POSIX.2 Shell y utilidades

a

POSIX.3 Métodos para medir la conformidad con POSIX

a

POSIX.4 Extensiones de tiempo real

POSIX.4a Extensión de threads, o múltiples flujos de control

POSIX.4b Extensiones adicionales de tiempo real

POSIX.6 Extensiones de seguridad

POSIX.7 Administración del sistema

POSIX.8 Acceso a ficheros transparente a la red

POSIX.12 Interfases de red independientes del protocolo

POSIX.15 Extensiones de colas batch

POSIX.17 Servicios de directorios

a

Estándares IEEE ya aprobados

b

Estándar ISO/IEC ya aprobado

aspectos del sistema operativo. El estándar especifica la sintaxis y la semántica de

estos servicios del sistema operativo, de modo que los programas de aplicación

puedan invocarlos directamente. El estándar no especifica cómo se implementan

estos servicios; de este modo, los implementadores de sistemas pueden elegir la

implementación que crean más conveniente—y así competir entre ellos—, siempre

que cumplan la especificación de la interfase. Todos los estándares base

desarrollados hasta el momento lo han sido para lenguaje C. En el momento de

escribir este artículo está abierto el debate sobre si los estándares base deben

desarrollarse de forma independiente del lenguaje, y luego especificar interfases

concretas para los diferentes lenguajes de programación. La Tabla I y la Tabla II

muestran los estándares base que están siendo desarrollados por los grupos de

trabajo del POSIX.

Tabla II. Estándares base POSIX adicionales

P1224 Servicios de mensajería electrónica (X.400)

P1224.1 Interfase para portabilidad de aplicaciones X.400

P1238 Interfase de comunicaciones OSI

P1238.1 Interfase OSI de transferencia de ficheros

P1201.1 Interfase gráfica a usuario (ventanas)

2) Interfases en diferentes lenguajes de programación: Son estándares secundarios que

traducen a un lenguaje de programación concreto los estándares base. Los

lenguajes utilizados hasta el momento son Ada, Fortran 77, y Fortran 90, además

del lenguaje C, en el que se han especificado hasta el momento los estándares base.

La Tabla III muestra las interfases POSIX que están actualmente en desarrollo

para diferentes lenguajes de programación.

3) Entorno de Sistemas Abiertos. Estos estándares incluyen una guía al entorno

Tabla III. Lista de interfases POSIX para diferentes lenguajes de programación

POSIX.5 Interfases Ada

a

POSIX.9 Interfases Fortran 77

a

POSIX.19 Interfases Fortran 90

POSIX.20 Interfases Ada para las extensiones de tiempo real

a

Estándares IEEE ya aprobados

POSIX y los perfiles de entornos de aplicación. Un perfil de aplicación es una lista

de los estándares POSIX, con especificación de las opciones y parámetros

necesarios, que se requieren para un cierto entorno de aplicación. El objetivo

principal de los perfiles de aplicación es conseguir un conjunto pequeño de clases

de implementaciones de sistemas operativos bien definidas y que sean apropiadas

para entornos particulares de aplicaciones. La Tabla IV muestra la lista de

estándares que están siendo desarrollados en este grupo.

La necesidad del desarrollo de un estándar de sistema operativo se deriva del hecho de

Tabla IV. Lista de estándares POSIX de entornos de aplicaciones

POSIX.0 Guía al entorno POSIX de sistemas abiertos

POSIX.10 Perfil de entorno de aplicaciones de supercomputación

POSIX.11 Perfil de entorno de aplicaciones de procesado de

transacciones

POSIX.13 Perfiles de entornos de aplicaciones de tiempo real

POSIX.14 Perfil de entorno de aplicaciones multiprocesadoras

POSIX.18 Perfil de entorno de aplicación de plataforma POSIX

que, aunque el UNIX es un estándar de facto, hay suficientes diferencias entre las

diferentes implementaciones para que las aplicaciones no sean completamente portables.

Más aún, si una aplicación UNIX puede necesitar ciertos cambios para ser portada a una

plataforma diferente, la portabilidad de las aplicaciones de tiempo real es muchísimo más

difícil, ya que existe una gran diversidad de sistemas operativos de tiempo real. El UNIX

no es un sistema operativo de tiempo real, y no existe un estándar de facto para estas

aplicaciones.

Practica 3

#include
#include
#include
#include
#include
#include
#define NUM_HIJOS 3//
int main(void)
{
int ret,i;
for(i=0;i ret=fork();
if(ret==0){
printf("Yo soy el hijo %d mi padre es PID=%d,yo soy PID=%d\n",i,getppid(),getpid());
} else if(ret>0){
ret=wait(NULL);
while(ret>0){
ret=wait(NULL);
}

if(ret== -1 && errno!= ECHILD){
perror("fallo en wait");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
else if(ret==-1){
perror("fallo en fork");
exit(EXIT_FAILURE);
}
}
}

Practica 2 "num_hijos

#include
#include
#include
#include
#include
#include

#define NUM_HIJOS 3//
int main(void)
{
int ret,i;
for(i=0;iret=fork();
if(ret==0){
printf("YO SOY EL HIJO %d, MI PADRE es PID=%d,yo soy PID=%d",i,getppid(),getpid());
}else if(ret>0){
ret=wait(NULL);
while(ret>0){
ret=wait(NULL);
}
if(ret==-1 && errno!=ECHILD){
perror("fallo en wait");
exit(EXIT_FAILURE);

exit(EXIT_SUCCESS);
}

else if(ret==-1){
perror("fallo en fork");
exit(EXIT_FAILURE);
}
}
}
}

Programa de arbol

#include
#include
#include
#include
#include
#include

int main (void) {

/**ATENCIÓN: Declaración de variables del programa a probar. Es sólo un exemplo**/
int i;
int n = 4;
int childpid;

/**El resto de variables son para que la presentación de los resultados por pantalla sea posible**/

int a, p;
int ret;
FILE *fpipe;
char comanda[50]; /*String dónde se guarda el comando a ejecutar por el 1r hijo*/
char line[256];
p = getpid();

sprintf(comanda,"pstree -n -p %d\n",getpid()); /*Concatenamos el comando pstree con el pid del padre*/

ret = fork();

if (ret == 0) { /*Este es el primer hijo del padre*/
if ( !(fpipe = (FILE*)popen(comanda,"r")) ) { /* Si el pipe falla*/
perror("Problemas con el pipe!!!");
exit(1);
}
while ( fgets( line, sizeof line, fpipe))
{
printf("%s", line); /*Escribimos por pantalla lo que retorna el hijo. La salida del pstree*/
}
pclose(fpipe);


} else {
/*El primer hijo sólo se crea para hacer un pstree y poder ver por pantalla */
/*el árbol de procesos generado*/

/*El código que viene a continuación, lo podéis substituir por lo que se tercie*/
/*¡¡Las variables han de ir declaradas arriba!!!*/


for (i = 1; i < n; i++) {
if ((childpid = fork()) == -1) {
break;
}
fprintf(stderr, "Este es el proceso %ld com padre %ld\n", (long)getpid(), (long)getppid());
}
sleep(1); /*Es sólo para dar tiempo a terminar a todos los hijos*/

}
exit(0);
}



¿Por que aparecen los mensajes repetidos?
R=para que muestren mensajes repetidos el truco es aprovechar que la función fork, que permite crear nuevos procesos, copia todo el proceso del llamador. Y eso incluye a los file descriptors del pipe, pero el pipe no se duplica Y esto da como resultado que si el padre escribe en p[1], el hijo puede leer en p[0], o viceversa.

2.- ¿Que observas?
R=primer proceso termine de procesar para que el otro comienze es decir son procesos completamente independientes y corren al mismo tiempo

3.- ¿Por que ?
Un pipe puede ser más útil en el caso de comunicar un proceso padre con un proceso hijo y se pueden usarse para leer y escribir bytes

PROGRAMA PID

#include
#include
#include
#include
#include


int main (int arge, char * argv[])
{
int num;
pid_t pid;

for(num=0; num < 3; num++)
{
pid = fork();
printf("Soy el proceso pid %d y mi padre tiene %d de pid \n",
getpid(), getppid());

if (pid != 0)
{
break;
srandom(getpid());
sleep (random() %3);
}


}


if (pid != 0)
{


printf("Fin del proceso pid %d \n", wait (NULL));
return 0;
}
}

IDentificadores
Process ID (PID)

Al crearse un nuevo proceso se le asigna un identificador de proceso único. Este número debe utilizarse por el administrador para referirse a un proceso dado al ejecutar un comando.
Los PID son asignados por el sistema a cada nuevo proceso en orden creciente comenzando desde cero. Si antes de un reboot del sistema se llega al nro. máximo, se vuelve a comenzar desde cero, salteando los procesos que aún estén activos.

fork().

Un proceso se crea invocando a una función del sistema operativo llamada fork(). La función fork() crea una copia idéntica del proceso que la invoca con excepción de:
* El nuevo proceso tiene un PID diferente
* El PPID del nuevo proceso es el PID del proceso original
* Se reinicia la información de tarificación del proceso (uso de CPU, etc.)

¿Por que aparecen mensajes repetidos?

por que estos mensajes estan contenidos en La clase Random que proporciona un generador de números aleatorios

¿Que observas?

El PPID de un proceso que viene siendo el PID de su proceso padre.

¿por que?

se realiza por la vía de duplicar un proceso existente invocando al comando fork(). Al proceso original se le llama "padre" y al nuevo proceso "hijo".

CABECERAS

NOMBRE
sys/types.h - data types sys / types.h - tipos de datos
SYNOPSIS SINOPSIS
#include # Include

DESCRIPTION DESCRIPCIÓN
The header shall include definitions for at least the following types: La cabecera deberá incluir las definiciones de por lo menos los siguientes tipos:

blkcnt_t blkcnt_t
Used for file block counts. Utilizado para el recuento de bloqueo de archivos.
blksize_t blksize_t
Used for block sizes. Se utiliza para tamaños de bloque.

NOMBRE
sys/wait.h - declarations for waiting sys / wait.h - declaraciones de espera
SYNOPSIS SINOPSIS
#include # Include

DESCRIPTION DESCRIPCIÓN
The header shall define the following symbolic constants for use with waitpid () : La cabecera definirá las siguientes constantes simbólicas para su uso con waitpid () :

WCONTINUED WCONTINUED
[ XSI ] [ XSI ] Report status of continued child process. Informe sobre el estado del proceso hijo continuó.
WNOHANG WNOHANG
Do not hang if no status is available; return immediately. No cuelgue si no se dispone de la condición, el retorno inmediato.
WUNTRACED WUNTRACED
Report status of stopped child process. Informe sobre el estado del proceso hijo parado.

S.O. Caracteristicas de Android, Chrome

Android

Es un sistema operativo basado en GNU/Linux diseñado originalmente para dispositivos móviles, tales como teléfonos inteligentes, pero que posteriormente se expandió su desarrollo para soportar otros dispositivos tales como tablets, reproductores MP3, netbooks, PCs, televisores, lectores de e-books e incluso, se han llegado a ver en el CES, microondas y lavadoras .

Fue desarrollado inicialmente por Android Inc., una firma comprada por Google en 2005. Es el principal producto de la Open Handset Alliance, un conglomerado de fabricantes y desarrolladores de hardware, software y operadores de servicio. Las unidades vendidas de teléfonos inteligentes con Android se ubican en el primer puesto en los Estados Unidos, en el segundo y tercer trimestres de 2010, con una cuota de mercado de 43,6% en el tercer trimestre.

Android tiene una gran comunidad de desarrolladores escribiendo aplicaciones para extender la funcionalidad de los dispositivos. A la fecha, se han sobrepasado las 250.000 aplicaciones disponibles para la tienda de aplicaciones oficial de Android: Android Market, sin tener en cuenta aplicaciones de otras tiendas no oficiales para Android, como pueden ser la App Store de Amazon o la tienda de aplicaciones de Samsung. Android Market es la tienda de aplicaciones en línea administrada por Google, aunque existe la posibilidad de obtener software externamente. Los programas están escritos en el lenguaje de programación Java. No obstante, no es un sistema operativo libre de malware, aunque la mayoría de ello es descargado de sitios.

Google Chrome OS

Es un proyecto llevado a cabo por la compañía Google para desarrollar un sistema operativo basado en web. A través de su blog oficial, Google anunció el 7 de julio de 2009 que Google Chrome OS será un sistema realizado con base en código abierto (Núcleo Linux) y orientado inicialmente para miniportátiles, estando disponible en junio de 2011. Funcionará sobre microprocesadores con tecnología x86 o ARM.

Google ha declarado que el código fuente del proyecto Google Chrome OS fue liberado en noviembre de 2009 bajo el proyecto «Chromium OS», para incorporar la colaboración de la comunidad de software libre y ayudar en el desarrollo del proyecto.

Lanzamiento del código abierto

El 19 de noviembre de 2009 se lanzó el proyecto abierto Chromium OS, proyecto que permite la colaboración abierta del desarrollo del sistema operativo de Google. El núcleo del sistema es Linux, y cuenta con herramientas del ambiente Linux.

Chrome Notebook (Cr-48)

El 7 de diciembre de 2010, Google anunció un programa piloto que consiste en enviar una computadora portátil (notebook) sin costo alguno, a aquellas personas residentes en Estados Unidos que quieran empezar a probar, en una etapa previa, el sistema operativo Chrome OS. El computador cuenta con una conexión 3G, gracias al proveedor de telefonía móvil Verizon, conexión Wi-Fi, una pantalla LCD de 12,1 pulgadas, cámara integrada, tapete táctil multitáctil, y un teclado modificado especialmente para Chrome OS.

Chromebook

El 11 de mayo de 2011, en el evento Google I/O son presentados dos Chromebooks potenciados con Chrome OS, fabricados por Samsung y Acer. Ambos Chromebooks cuentan con discos SSD, sin unidad óptica, tapete multitáctil, pantallas de 12,1 y 11,6 pulgadas, conexión Wi-Fi o 3G, y con baterías de larga duración de hasta 8,5 horas continuas. El 15 de junio de 2011 los Chromebooks se lanzan a la venta para el público, con precios desde los $349 hasta los $499 USD.

Características fundamentales

Interfaz de usuario

Chrome OS está diseñado de una forma minimalista, debido a que su principal herramienta es el navegador web Google Chrome. De esta forma, la compañía planea mover gran parte de la interfaz de usuario desde un entorno de escritorio hacia Internet. De hecho, Google se refiere a su proyecto Chrome OS como una extensión natural del navegador Chrome. En otras declaraciones para una audiencia de desarrolladores, Google enfatiza que la web es la plataforma, destacando que las aplicaciones basadas en web funcionarán en Chrome y viceversa.

Las principales características de la interfaz de usuario son:

• Paneles: Los paneles son pequeñas ventanas inferiores que se utilizan para diferentes tareas, tales como la descarga de archivos, navegador de archivos, mensajería instantánea en Gtalk, tomar notas, o notificadores de eventos como Google Calendar, Gmail, y actualizaciones del sistema. Los paneles también permiten ser minimizados para ocultarse, y también se pueden utilizar mientras se navega en diferentes sitios al permanecer estáticos.
• Indicadores: Los indicadores se encuentran en la parte superior derecha, e indican procesos como la hora, batería, conexión y selector Wi-fi, y conexión 3G.
• Pestañas: Las pestañas son lo más utilizado en el sistema, se utilizan para abrir las aplicaciones y sitios, y permiten abrir opciones del sistema. Las pestañas también se pueden "fijar" y disminuir su tamaño para quedar ancladas en la parte superior izquierda.
• Lanzadores: Los lanzadores aparecen en la página principal, y son iconos grandes que se utilizan para abrir aplicaciones web, también ver los sitios más visitados, y ver los marcadores en una barra superior.

Evolucion Historica de los Sistemas Operativos

Clasificaremos el desarrollo de los sistemas operativos en generaciones

Primera Generacion (1945-1955)

En esta época no existían los sistemas operativos. Utilización de la tecnología de las válvulas o tubos de vacío que hacían que los ordenadores fuesen enormes. El usuario tenía que hacer todos los programas en código binario. Las máquinas eran de un enorme coste. El monitor es el programa antepasado del Sistema Operativo. Abarca funciones muy elementales, como visualizar y modificar los contenidos de la memoria principal, el lanzamiento automático

Actualmente, al estar superado el concepto de mono programación, es frecuente que tengamos que familiarizarnos con los conceptos de multiprogramación, tiempo compartido, multiproceso y tiempo real. para la ejecución de un programa, la introducción de puntos de ruptura en los programas para puesta a punto, etc.

Segunda Generación (1955-1965)

al menos un proveedor ofrecía un sistema de multiprocesamiento, que era un sistema de computo que tenía más de una unidad central de proceso. En realidad el sistema consistía en dos computadoras completas Un sistema operativo ubicado en la computadora más grande indicaba a la máquina de control que necesitaba servicio.

Los primeros sistemas en líneas presentaban programas de sistema operativo diseñados especialmente para controlar los recursos de la computadora Primero se arma un mensaje de entrada en un buffer de comunicaciones; puede cambiarse el código de este mensaje y trasladarse a una cola de entrada en la memoria mediante un programa de aplicación. Esta generación se caracteriza por la utilización de la tecnología que incluye transistores

Tercera Generación (1965-1980)

batch de la tercera generación introdujeron el concepto de multiprogramación, proceso muy similar a las técnicas de sacar y meter programas desarrollados para el tiempo compartido. La multiprogramación ha ayudado a incrementar la productividad, o sea el número de trabajos por unidad de tiempo.

•Sistemas en línea : Durante la tercera generación, los sistemas operativos vinieron con más módulos para facilitar el desarrollo de los sistemas en línea, especialmente para respaldar el procesamiento de terminales y telecomunicaciones. •La tecnología utilizada en este período corresponde a la de circuitos integrados, •Otra característica importante de los sistemas operativos de esta generación es la aparición de la •técnica de Spooling (Operación simultánea y en línea de periféricos . •Durante esta generación aparecen los primeros sistemas de Tiempo compartido

Cuarta Generación (1980-1990)

Esta generación se caracteriza por la utilización de los microprocesadores empezaron a utilizar en la empresa y en las universidades recibieron el nombre de estaciones de trabajo. Durante esta generación aparecen los sistemas operativos que proporcionan una interfaz más amigable al usuario

Los sistemas operativos que cobran gran popularidad en este período son MS-DOS de Microsoft y UNIX. DOS (sistema operativo en disco) VERSIONES: PC-DOS (IBM) DR-DOS (Digital Research) MS-DOS 1.0 Abril 1981 7.0 Agosto 1995 Se trata del 1º sistema operativo creado para ordenadores personales en la década de los 80 dado que los sistemas anteriores fueron creados para maquinas grandes en entornos de empresaSe trata de un sistema operativo grabado sobre disco de modo que se ha de encontrar permanentemente activo y residente para poder trabajar con esa maquina. Esto ahora parece intrascendente ya que todos los sistemas operativos (Windows, Windows9.x, unix, linux, etc..) extendido pasando a adoptar la numeración de la versión de Windows. En la actualidad la versión 7.0 aun siendo la más reciente no es la mas difundida ya que esta muy arraigada la 6.22.

CARACTERISTICAS DEL SISTEMA a)Monotarea.- Ya que no dispone de gestores de memoria protegida para ejecutar cada aplicación b)Monopuesto.- Ya que no permite gestionar espacios de memoria distintos para diferentes usuarios

c)Monoproceso.-Porque no esta diseñado para trabajar con mas de un procesador a la vez y tampoco ninguna de las aplicaciones desarrolladas para ver esto. d)Entorno de texto.- Con fondo negro y ejecución en modo carácter por medio de comandos u ordenes y sus parámetros cuya sintaxis se ha de respetar.

PROCESO BATCH O POR LOTES •Se emplean en la automatización de tareas que exigen de crear varios comando con sus parámetros y también para personalizar un entorno de trabajo bajo DOS. •Admite cualquier comando visto hasta ahora y otra serie de ellos específicos para procesos BAT como son los siguientes: •CALL, IF, KEYB, LOAD, PATH, PAUSE, PROMPT, SET, GOTO, MENU....

Quinta Generación (1990 - Actualidad)

•Desde aproximadamente mediados de los '80 surgió el crecimiento de las redes de computadores con sistemas operativos de red y sistemas operativos distribuidos. •El desarrollo de los sistemas computacionales de los últimos tiempos ha generado un conjunto de estándares,

•Estándares de comunicaciones abierto •Modelo OSI (Open System Interconection), desarrollado por I SO. •Estándares de sistemas operativos abiertos •POSIX (IEEE standar 1003.1) •SVID (System V Interfase Definition) •Estándares de interfaces de usuarios abiertos •X Windows desarrollado por MIT •Estándares de aplicaciones de usuarios abiertos •X/Open •OSF (Open Software Foundation

•La mezcla de sistemas continúa durante la tercera y cuarta generación. •El sistema operativo consiste en una serie de manejadores y cada manejador debe lograr lo •siguiente: controlar los recursos •Explotación del proceso en paralelo y de forma concurrente. •Integración mediante informática corporativa del tratamiento en distintos Sistemas Operativos •de micros, minis y mainframes,

Avances Evolutivos •trajo consigo modificaciones •mejoras a los sistemas operativos •adicionó hardware especial ayuda a traducir las direcciones virtuales. Este mapeo puede lograrse mediante software o hardware. •utilizan direcciones que sobrepasan el tamaño de la memoria primaria de la computadora en un sistema virtual

Un sistema operativo es un conjunto de rutinas que proveen facilidades para con dos funciones principales: manejo de recursos y embellecimiento. Era tan complejo su manejo, que en algunos casos el resultado llegaba a ser desastroso. Se buscaron medios más elaborados para manipular la computadora, para que el usuario pueda operar la computadora con un entorno, lenguaje y operación

En 1955 comenzó el desarrollo de los lenguajes de alto nivel . Las funciones del operador tenían más directamente que ver con la administración y control de los recursos del Sistema Operativo y la carga de trabajos, y las de los programadores con la codificación de los programas.

sistemas