Practica num Aleatorios

#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#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);
    }

}

POSIX

Es el acrónimo de Portable Operating System Interface; la X viene de UNIX como seña de identidad de la API.

El término fue sugerido por Richard Stallman en respuesta a la demanda de la IEEE, que buscaba un nombre fácil de recordar. Una traducción aproximada del acrónimo podría ser "Interfaz de sistema operativo portable".

POSIX.1, Core Services (implementa las llamadas del ANSI C estándar). Incluye:

• Creación y control de procesos.
• Señales.
• Excepciones de punto flotante.
• Excepciones por violación de segmento.
• Excepciones por instrucción ilegal.
• Errores del bus.
• Temporizadores.
• Operaciones de ficheros y directorios (sobre cualquier fs montado).
• Tuberías (Pipes).
• Biblioteca C (Standard C).
• Instrucciones de entrada/salida y de control de dispositivo (ioctl).

TOTALMENTE POSIX-COMPATIBLES

Los siguientes Sistemas Operativos son 100% compatibles con uno o varios estándares POSIX.

• A/UX
• AIX
• BSD/OS
• DSPnano
• HP-UX
• INTEGRITY
• IRIX
• LynxOS
• Mac OS X v10.5 en Procesadores Intel.
• MINIX
• MPE/iX
• QNX (IEEE Std. 1003.13-2003 PSE52;
• RTEMS (POSIX 1003.1-2003 Profile 52)
• Solaris
• Unison RTOS
• UnixWare
• velOSity
• VxWorks (IEEE Std. 1003.13-2003 PSE52

Listado de Código 1.2: Ejemplo de programa con hilos POSIX

#include <pthread.h> #include <stdlib.h> #include <unistd.h> void *thread_function(void *arg) { int i; for ( i=0; i<20; i++ ) { printf("Thread says hi!\n"); sleep(1); } return NULL; } int main(void) { pthread_t mythread; if ( pthread_create( &mythread, NULL, thread_function, NULL) ) { printf("error creating thread."); abort(); } if ( pthread_join ( mythread, NULL ) ) { printf("error joining thread."); abort(); } exit(0); }

PRACTICA 3

 #include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#define NUM_HIJOS 3

int main (void)
{
int ret,i;
for(i=0;i<NUM_HIJOS;i++)
    {
        ret=fork();
        if(ret==0)
        {
            printf("Yo soy el hijo %d, mi padre es PID=%d, yo soy PID=%d \n",i,getpid(),getpid());
        }
        else if (ret>0)
        {
            ret=wait(NULL);
            while(ret>0)
            {
                ret=wait(NULL);
            }
  
        }
  
    if(ret==-1 && errno!=ECHILD)
        {
            perror("Falo en WAIT");
            exit(EXIT_FAILURE);
      
        exit(EXIT_SUCCESS); //  }
    }  
    else if(ret==-1)
    {
        perror("Fallo en Fork");
        exit(EXIT_FAILURE);
    }  
}  
}

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#define NUM_HIJOS 2

int main (void)
{
int ret,i;
for(i=0;i<NUM_HIJOS;i++)
    {
        ret=fork();
        if(ret==0)
        {
            printf("Yo soy el hijo %d, mi padre es PID=%d, yo soy PID=%d , el otro hijo es=%d\n",i,getpid(),getpid(),getppid());
        }
        else if (ret>0)
        {
            ret=wait(NULL);
            while(ret>0)
            {
                ret=wait(NULL);
                   
                       
           }
   
        }
   
    if(ret==-1 && errno!=ECHILD)
        {
            perror("Falo en WAIT");
            exit(EXIT_FAILURE);
       
        exit(EXIT_SUCCESS);
    }   
    else if(ret==-1)
    {
        perror("Fallo en Fork");
        exit(EXIT_FAILURE);
    }   
}   
}

PRACTICA 2

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

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);
}


¿PORQUE APARECEN MENSAJES REPETIDOS?
Por que se va incrementando con cada nuevo proceso creado con una llamada fork().


¿QUE OBSERVAS?
El llamado de varios procesos hijos diferentes


¿POR QUE?
Por que es un arbol y este puede tener de cero a mas hijos conectados a el.

PROGRAMA

Las llamadas al sistema fork características:

fork: En el momento de la llamada a fork el proceso hijo:

• es una copia exacta del padre excepto el PID.

• tiene las mismas variables y ficheros abiertos.

• las variables son independientes (padre e hijo tienen distintas

memorias).

• los ficheros son compartidos (heredan el descriptor).

clone: permite especificar qué queremos que compartan padre e hijo.

• espacio de direccionamiento

• información de control del sistema de archivos (file system)

• descriptores de archivos abiertos. 

• gestores de señales o PID.

El getpid () la función devolverá el ID del proceso del proceso invocador.

#include <sys/type.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>

int main(int arge, char *argr[]) {
    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 de PID %d \n", wait(null));
return 0;
}

PREGUNTAS

¿POR QUE APARECEN MENSAJES REPETIDOS?

Por que el srandom  cambia el origen del generador de números aleatorios.
Valor de retorno:srandom no devuelve ningún valor.

¿QUE OBSERVAS?

Que se va incrementando con cada nuevo proceso creado con una llamada fork().

¿POR QUE?

Alcanza un cierto valor límite se empieza otra vez desde 0, buscando números que no estén asignados ya a otro proceso en ejecución.

Sistema Operativo Androi

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.

• Aplicaciones: las aplicaciones base incluyen un cliente de correo electronico, programa de SMS, calendario, mapas, navegador, contactos y otros. Todas las aplicaciones están escritas en lenguaje de programación Java.

• Marco de trabajo de aplicaciones: los desarrolladores tienen acceso completo a los mismos APIs del framework usados por las aplicaciones base. La arquitectura está diseñada para simplificar la reutilización de componentes; cualquier aplicación puede publicar sus capacidades y cualquier otra aplicación puede luego hacer uso de esas capacidades (sujeto a reglas de seguridad del framework). Este mismo mecanismo permite que los componentes sean reemplazados por el usuario.

• Bibliotecas: Android incluye un conjunto de bibliotecas de C/C++ usadas por varios componentes del sistema. Estas características se exponen a los desarrolladores a través del marco de trabajo de aplicaciones de Android; algunas son: System C library (implementación biblioteca C estándar), bibliotecas de medios, bibliotecas de gráficos, 3D y SQLite, entre otras.

• Runtime de Android: Android incluye un set de bibliotecas base que proporcionan la mayor parte de las funciones disponibles en las bibliotecas base del lenguaje Java. Cada aplicación Android corre su propio proceso, con su propia instancia de la máquina virtual Dalvik. Dalvik ha sido escrito de forma que un dispositivo puede correr múltiples máquinas virtuales de forma eficiente. Dalvik ejecuta archivos en el formato Dalvik Executable (.dex), el cual está optimizado para memoria mínima. La Máquina Virtual está basada en registros y corre clases compiladas por el compilador de Java que han sido transformadas al formato .dex por la herramienta incluida "dx".

• Núcleo Linux: Android depende de Linux para los servicios base del sistema como seguridad, gestión de memoria, gestión de procesos, pila de red y modelo de controladores. El núcleo también actúa como una capa de abstracción entre el hardware y el resto de la pila de software.

TAREA 1 ASPECTOS HISTORICOS DEL DESARROLLO DE LOS SISTEMAS OPERATIVOS

El desarrollo de los sistemas operativos esta muy relacionado con el desarrollo de las arquitecturas de los sistemas computacionales, por esta razón clasificaremos el desarrollo de los sistemas operativos en generaciones que han sido marcadas en base a las tecnologías de construcción de dichas arquitecturas.

Primera Generación (1945-1955):

La lógica o software de los ordenadores se ha complicado conforme han evolucionado éstos. Los primeros ordenadores, a partir de 1944 en que Aiken construyó el Mark-I, sólo podían programarse en lenguaje máquina, y puede decirse que el Sistema Operativo aún no existía.

J. V. Neumann fue quien dio el primer paso en la informática y en las relaciones hombre-máquina con el concepto de programa almacenado, que consiste en archivar en el ordenador un conjunto de instrucciones máquina para posteriormente ejecutarlas. La aparición del Assembler, lenguaje nemotécnico-simbólico, constituyó un gran avance sobre la primitiva programación en código máquina. La forma de explotar los sistemas ha ido evolucionando con el tiempo; los más sencillos funcionaban con monoprogramación. Monoprogramación o monoejecución es el sistema de explotación en el que se ejecuta solamente un programa cada vez y no comienza la ejecución de otro hasta terminar con el anterior.

En 1948, con Noam Chomsky, surge la teoría de las gramáticas generativas transformacionales, que es la base de los traductores de lenguajes. En 1955 comenzó el desarrollo de los lenguajes de alto nivel, y al mismo tiempo se empezó a dividir el trabajo entre personas: operadores y programadores. 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.

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 para la ejecución de un programa, la introducción de puntos de ruptura en los programas para puesta a punto, etc. Gracias al monitor apareció el concepto de secuencia automática de trabajos.

Actualmente, al estar superado el concepto de monoprogramación, es frecuente que tengamos que familiarizarnos con los conceptos de multiprogramación, tiempo compartido, multiproceso y tiempo real.

Segunda Generación (1955-1965):

Multiprocesamiento : Durante la segunda generación , 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; las computadora más pequeña tenía un sistema operativo y controlaba ambas máquinas. La computadora más grande era esclava de la más pequeña. La computadora pequeña procesaba la entrada de información y ordenaba e imprimía toda la salida utilizando todos los discos como entrada de almacenamiento temporal. Un sistema operativo ubicado en la computadora más grande indicaba a la máquina de control que necesitaba servicio.

Sistemas en línea :Los primeros sistemas en líneas presentaban programas de sistema operativo diseñados especialmente para controlar los recursos de la computadora. Los programas de aplicación de un sistema en linea expresan la lógica de aplicación y los llamados mediante programas de sistemas.

El supervisor de un sistema en línea establece una serie de colas y programa el servicio. 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. El sistema operativo registra este mensaje en la cola de mensajes a procesarse.

Cuando la unidad central de proceso esta disponible el supervisor le ordena que atienda una cola, por ejemplo la que contiene un mensaje de entrada. Un programa de aplicación llamado mediante el sistema operativo puede verificar la corrección del mensaje, después de lo cual el mensaje se coloca en una cola de trabajo.

El nacimiento del tiempo compartido : Los primeros sistemas de negocios también estaban utilizando sistemas operativos para sus equipos de segunda generación. Cuando fue anunciada la tercera generación de computadoras los fabricantes claramente habían abrazado la idea de un sistema operativo. La línea 360 de la IBM no podía funcionar sin la ayuda de tal sistema operativo maneja toda la entrada/salida por medio de interrupciones. De hecho existen interrupciones especiales que la computadora solo puede ejecutar cuando está en estado supervisor, bajo el control de los sistemas operativos.

Esta generación se caracteriza por la utilización de la tecnología que incluye transistores. Estos proporcionan mejores características que los tubos al vacío: son más pequeños, disipan menos calor y son más rápidos.

En esta época, ya no hay un solo grupo que se dedica a diseñar, construir, operar y mantener el sistema computacional, sino que la mantención la realizan otras personas. La programación, en este período se ve apoyada por la creación de lenguajes ensambladores ylenguajes de alto nivel; como Fortran y Cobol .

Para optimizar el tiempo de utilización del sistema computacional, se adoptó el Procesamiento por Lotes. Este procedimiento se puede resumir en los siguientes pasos:

• Varios trabajos son leídos desde tarjetas perforadas y almacenados en cinta
• El computador ejecuta programas que lee de una cinta y escribe los resultados en otra cinta.
• Los resultados escritos en la cinta son desplegados a través de la impresora.

Como consecuencia de la utilización de tecnología de mejores características, el procesamiento por lotes, la utilización de un operador de sistema y un sistema operativo primitivo se logró minimizar el tiempo ocioso de los computadores.

Tercera Generación (1965-1980):

Multisistemas : El estudio del hardware se menciona el desarrollo de los canales de datos para absorber algo de carga de E/S de la CPU. Sin embargo, todavía existía un equilibrio entre la UCP y la E/S aún con la ayuda de los canales en la mayor parte de los sistemas comerciales que tienen mucha actividad de E/S se puede tener la UCP ociosa más del 50% del tiempo principalmente debido a la espera de la terminación de operaciones de entrada/salida.

Los sistemas operativos en 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. En la multiprogramación hay más de un programa semiactivo en la memoria a la vez. La multiprogramación intenta ocultar retrasos de E/S cambiando a UCP a otro programa cuando no puede procesar por más tiempo el que estaba procesando, debido a un solicitud de E/S.

La multiprogramación ha ayudado a incrementar la productividad, o sea el número de trabajos por unidad de tiempo. Sin embargo, puede tomar más tiempo correr un solo trabajo bajo multiprogramación que bajo un procesador unitario, a causa de las interrupciones.

No debe confundirse la multiprogramación con el multiprocesamiento. En un sistema de multiprogramación, la unidad central de procesamiento ejecuta solamente un programa a la vez. Varios programas están presentes en la memoria en un estado semiactivo; su ejecución ha sido suspendida temporalmente. Algunos sistemas de la tercera generación también presentan el multiprocesamiento, o sea la presencia de más de una unidad central de proceso. Estos procesadores están controlados por el sistema operativo y, por supuesto, son multiprogramados ya que por lo menos existe el potencial para ejecutar un programa en cada procesador al mismo tiempo. Estos sistemas multiprocesadores con atractivos en un ambiente de fuerte actividad computacional o como respaldo. Varios sistemas de tiempo compartido, por ejemplo, utilizan el multiprocesamiento.

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. Los sistemas estaban diseñados para apoyar una mezcla de procesamiento batch y consultas en línea.

Tiempo compartido: Durante la tercera generación, el proyecto MAC del MIT desarrolló también un nuevo sistema de tiempo compartido llamado MULTICS. Este sistema presenta una importante innovación que influyó en los sistemas de cómputo posteriores. Un objetivo del MULTICS era proporcionar al programador la apariencia de una memoria real. La memoria virtual puede producirse combinando la segmentación y la paginación enfoque que también facilita el desarrollo de los procedimientos re-entrantes. Básicamente, un programa y sus datos se dividen en páginas. Solamente se cargan en un momento dado, las páginas necesarias en el almacenamiento primario; las otras páginas se mantienen en dispositivos de almacenamiento secundario.

La tecnología utilizada en este período corresponde a la de circuitos integrados, lo cual permitió construir máquinas más baratas y con mejor rendimiento. La empresa IBM fue la primera en utilizar esta tecnología.

Una de las principales características de los sistemas operativos de hoy, que aparecen en esta generación es la Multiprogramación. Esta técnica consiste en particionar la memoria de manera de contener simultáneamente muchos trabajos, lo que permite independencia en las acciones de la máquina. Por ejemplo, si un trabajo está esperando por Entrada/Salida, otro trabajo puede estar utilizando la CPU. Con la utilización de la multiprogramación, se mejora el tiempo de utilización de la CPU, pero se crean problemas de protección y seguridad, debido al particionamiento de la memoria.

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 ). Esta consiste en la capacidad de leer los trabajos de cinta al disco,  haciendo posible que a medida que hubiera espacio en memoria se podía pasar al siguiente trabajo. De esta manera las operaciones de periféricos se realizan en paralelo con la utilización de la CPU.

Durante esta generación aparecen los primeros sistemas de Tiempo compartido, esto consiste en que se le asigna a cada trabajo un tiempo fijo de utilización de CPU, este período de tiempo (denominado time slot) es pequeño, pues el uso de tiempo compartido tiene como objetivo manejar a distintos usuarios mediante terminales que tengan la ilusión de estar ocupando la máquina como si fueran únicos. El primer sistema operativo importante de tiempo compartido es el (CTSS) y fue desarrollado en MIT.

Otros de los sistemas que surgió en este periodo es MULTICS, el que sirvió de base para el desarrollo del sistema UNIX.

Cuarta Generación (1980-1990):

Esta generación se caracteriza por la utilización de los microprocesadores para la construcción de computadores de menor tamaño, haciendo posible que una sola persona tuviera su propio computador personal. Los computadores personales con mayores capacidades y que se 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, esto se traduce en mejores herramientas de interacción con el computador, tales como capacidades gráficas, íconos, sistemas de menús, etc.

Los sistemas operativos que cobran gran popularidad en este período son MS-DOS de Microsoft y UNIX. Este último tuvo sus primeros desarrollos en Berkeley y posteriormente en AT&T.

DOS (sistema operativo en disco)

VERCIONES:

PC-DOS (IBM)

DR-DOS (Digital Research)

MS-DOS 1.0 Abril 1981

1.1

2.0

3.0

3.1

3.2

MS-DOS (Microsoft) ! 3.3

! 4.0

5.0

! 6.0

6.2

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 empresa. A lo largo del tiempo pugnaron tres fabricantes por la hegemonía del mercado hasta que en la década de los 90 con la aparición de las 1as plataformas de Windows 3.0 3.1 y 3.11 Microsoft se queda sola por la retirada de los demás aunque ya IBM lo había dejado mucho tiempo antes.

Se 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..) Están ocupando algunos de los discos duros del ordenador pero al principio los ordenadores no tenían disco duro ya que aun no se habían inventado y por tanto se encontraba en un diskette que debía estar permanentemente introducido con el agravante de que solo había una disquetera.

Entre todas las versiones que salieron al mercado y omitiendo las primeras muy dependientes de la rudimentaria tecnología de entonces son las versiones 3.3,4.0 y 6.2 las que tuvieron un mayor éxito comercial. 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. Por otro lado estas versiones han dejado paso a aquellas otras que dependen de Windows como sistema mayoritariamente extendido pasando a adoptar la numeración de la versión de Windows.