Mostrando entradas con la etiqueta memoria. Mostrar todas las entradas
Mostrando entradas con la etiqueta memoria. Mostrar todas las entradas

jueves, 11 de junio de 2015

VARIABLES tercera parte: ARRAYS

Con los tipos vistos anteriormente prácticamente se podían realizar todas las operaciones del mundo dentro de unos margenes que venían de la limitación de la memoria de los ordenadores y de la capacidad de los microprocesadores de procesar dicha información.

Pero se daba el caso de que había problemas que con estos tipos solamente no podíamos solucionar. 

El ejemplo más sencillo lo tenemos en una agenda: si queremos crear una agenda con cien entradas lo podemos hacer de una manera un poco bruta creando 100 variables de tipo string y cada una de ellas guardará un nombre de la agenda. Pero además necesitamos 100 variables de tipo int para que almacenen los 100 números de teléfono de las cien personas.

Imagina cómo queda el programa de farragoso y los problemas que se generan al querer buscar algo en esa agenda ya que habría que ir variable por variable comparándolo con nuestra busqueda:

buscar "jose"

es var1="jose" 
 si final
 no es var2="jose"
  si final
   no es var3="jose"... 
    hasta var100 o final

Por eso se recurrió a un recurso que se usa en matemáticas para colocar un punto en dos ejes o en tres coordenadas: Los vectores.



Si usamos un vector para modelar la agenda creamos un vector de tamaño 100 para los nombres y otro vector de tamaño 100 para los teléfonos (c#):

            string[] nombre= new string [100];
            int[] teléfono=new int[100];
De esta manera nuestro código se simplifica bastante ya que ahora para recorrer todos los campos y comparar podemos usar un bucle, que vaya 1 por uno por todos nuestros datos hasta encontrar el que buscamos:

            for (int indice=0;indice<100;indice++)
                {
                if (nombre[indice]=="jose" )
                    {
                        Console.WriteLine("jose encontrado en posición "+indice);
                        break;
                    }
                }


Es decir, hemos reducido más de 100 lineas de código a menos de 10. Y no solo eso.

En nuestra primera versión del programa si queríamos aumentar en 100 más los datos de nuestra agenda teníamos que crear otras 100 variables más y de esta forma cada vez que fuéramos a hacer algo con ellos necesitaríamos otras 100 lineas más de código.

Sin embargo con un vector es tan sencillo como cambiar el valor del indice(c#):

            //Versión con indicemaximo variable más compacta y más útil
            const int indicemaximo=200;
            string[] nombres = new string[indicemaximo ];
            int[] teléfonos = new int[indicemaximo ];

            for (int indice = 0; indice < indicemaximo ; indice++)
            {
                if (nombres[indice] == "jose")
                {
                    Console.WriteLine("jose encontrado en posición " + indice);
                    break;
                }
            }

Con este avance lo siguiente era fácil de entender, por qué no usar las matrices para modelar los datos que sean iguales y funcionen juntos...


Dicho y hecho: en nuestro ejemplo en lugar de introducir solo el nombre podría darse el caso de que quisiéramos los apellidos y la dirección también, con lo cual nuestro modelo podría ser así:

string nombreapellidodirecion[indicemáximo,3];

Con lo cuál nuestro programa accedería directamente a estos tres datos de cada entrada de una vez y dispondrá de ellos solamente con una llamada a esa matriz:

nombreapellidodirecion [1,0] devuelve el nombre de la entrada 1
nombreapellidodirecion [1,1] devuelve el nombre de la entrada 2
nombreapellidodirecion [1,2] devuelve el nombre de la entrada 3

Con todo esto aumentaba en gran medida la velocidad con la que se podía acceder a los datos y además de esto disminuía el número de lineas necesarias para programar...
Pero como veremos más adelante esto acababa siendo ineficaz ya que la memoria se usaba con demasiada frecuencia y se acababa llenando... 

Con lo cual hubo que explorar otras vías...

[Continuará]


domingo, 7 de junio de 2015

VARIABLES 2: Tipos Básicos (INTEGER,CHAR...)

Podríamos decir que la importancia de las variables es tal, que sin ellas nos sería imposible hacer más que programas del tipo imprime un mensaje o pinta esto... Es decir, podríamos decir que son tan importantes como los ingredientes en una ensalada...

En nuestro caso tenemos ya dos tipos de variables simples que hemos conocido en el primer artículo sobre el tema: numéricas y alfanuméricas, es decir, variables de tipo número y variables de tipo letra, pero vamos a meternos en profundidad en el tema...



Alguien podría pensar que sería útil definir las variables número con el máximo rango posible, es decir, que se pudiera representar cualquier número de cualquier tamaño en cualquier caso... Y ya puestos sería deseable que pudiéramos poner los números con tantos decimales como necesitáramos y porque no, estos números podrían ser positivos o negativos...

Es decir, lo deseable sería que el tipo número fuera de rango infinito, y que fuera infinitamente divisible y que recorriera también los negativos... Es decir, lo deseable sería un número Real para poder hacer todas las operaciones que hacemos con los número reales...

Pero he aquí un problema: para representar cada número en memoria necesitamos una cantidad infinita de memoria, cosa que no tenemos, así que de momento nos olvidamos de infinitos números y de infinitos decimales.

Tenemos otro problema: por un lado cada dígito de un número entero se representa en base 2 en el ordenador, y cada dígito en base 2 se almacena en una posición de memoria y la memoria es limitada.

Cuando los ordenadores tenían hasta 16k, esto era un gran problema, ya que si usabas toda la memoria se producía un Overflow, es decir, un desbordamiento de memoria... Y se acababa el programa.



Con lo cual, teníamos que tener unos tipos de dato, unas variables de tamaño reducido para poder usar el resto de la memoria para programar. Por ello en aquellos ordenadores solo había los tipos número y alfanumérico, y además de tamaño reducido.

Con la mejora del tamaño de la memoria, los tipos se amplían, pero una preocupación fundamental sigue siendo el uso de esa memoria, es decir, si el campo al que va a representar esa variable no usa números muy grandes se usará un tipo de variable que use números pequeños.

En estos momentos, de lo que se trataba era de usar el mínimo de memoria para que nuestro programa fuera eficiente,y siempre intentar no llevarlo al máximo para evitar desbordamientos.

Siendo así llegamos al momento actual en el que podemos ver si queréis los tipos básicos, de un lenguaje al que tengo cariño, el C#:

De -128 a 127
Entero de 8 bits con signo
De 0 a 255
Entero de 8 bits sin signo
U+0000 a U+ffff
Carácter Unicode de 16 bits
De -32.768 a 32.767
Entero de 16 bits con signo
De 0 a 65.535
Entero de 16 bits sin signo
De -2.147.483.648 a 2.147.483.647
Entero de 32 bits con signo
De 0 a 4.294.967.295
Entero de 32 bits sin signo
De -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807
Entero de 64 bits con signo
De 0 a 18,446,744,073,709,551,615
Entero de 64 bits sin signo
(Fuente Microsoft.com)

Cuanto más grande es el número mayor bloque de memoria estamos usando. El signo, va a usar otro byte más por eso los tipos sin signo, uint, ulong, son el doble de grande que el de los tipos con signo int y Long.

De echo, hoy en día sigue siendo importante esto, ya que al usar los dispositivos móviles, es necesario que no llevemos al límite nuestros recursos...

El tipo que se usa como short en c# durante muchos años fue considerado como el tipo numérico por excelencia, usada en el spectrum, el amstrada cpc e incluso en los primeros pc...

Actualmente si usamos otros lenguajes de programación o si usamos c# pero ampliado, podemos manejar números todavía más grandes...

[Continuará]

jueves, 4 de junio de 2015

ESTRUCTURAS básicas en un programa: VARIABLES (Introducción)

Estamos siguiendo nuestra andadura y por algún lado tendremos que comenzar. Cuando nos acercamos al mundo de la programación lo primero que hay que saber es que quiere uno hacer.


Una vez que sabes qué, el siguiente problema es el cómo, y este cómo implica  en primer lugar que herramientas vas a utilizar, ya que a lo mejor si nuestro objetivo (target) es una página web, tal vez es necesario usar un programa que nos facilite el trabajo.

Es posible que incluso sin saber nada de programación seas capaz de crear una página web que sea bonita y útil, por ejemplo usando jimdo.com:


Pero si nos vamos a meter en faena y vamos a ensuciarnos las manos con código, es posible que necesitamos algún lenguaje de programación.

En los primeros ordenadores, aquellos que se construían con válvulas de vacío, los programas se "programaban" ensamblando partes, es decir, uniendo con cables unas partes con otras, y os podéis imaginar el trabajo tan tedioso que llevaba primero construir el programa y luego buscar errores.

Aquí tenéis la explicación de porqué cuando se compila un programa se le llama "Build" construir, porque en origen se construía de verdad.

También viene de esta época el término bug, error en programa, pues estas máquinas generaban tanto calor que los insectos se metían entre los cables y hacían que el programa fallara...


Posteriormente al inventar el transistor, el tamaño de los ordenadores ser redujo de forma radical, pasando de ocupar naves enteras a habitaciones y luego a caber en la palma de la mano...


Primeros lenguajes:


Cuando se empieza a programar una de las cosas más importantes de entender es donde se guardan los programas. Ese lugar es la memoria, la memoria es el lugar donde almacenamos el programa pero también los datos que usará ese programa.

Cuando se programaba en código de máquina esto era fácil de entender, ya que el código máquina lo que hacía era verter contenidos en memoria, moverlos y compararlos... Con eso se hacen todos los programas del mundo.

4A 3F 33 33
23
22 33 03 05

Pero el código máquina era tan farragoso, y tan complicado que lo primero que se creó fue un lenguaje el Assembler o ensamblador, que permitía en lugar de usar solo números identificar cada código con un nombre:

Mov ax, bx



El siguiente paso fue crear lenguajes más amables, más fáciles de entender y de esta época surge el BASIC, el Cobol, el Fortran...

Todos estos lenguajes se podían compilar o interpretar, pero tenían algo en común el uso de variables.

Variables:


Ya es el momento, ¿qué es una variable?

Una variable es una posición de memoria, es un lugar dentro de la memoria del ordenador, al que se le ha asignado un nombre.


A ese lugar se puede acceder nombrándolo, es decir, llamándolo para que nos devuelva el valor que tienen o también se le puede llamar para cambiar el contenido.

Un ejemplo sera muy gráfico. Volvamos al Basic por un momento, que es antiguo pero era muy claro:

10 let a=5
20 print a
30 let a=10
40 print a

Let en inglés es dejar, en este caso "deja en a el valor 5", luego Print es imprimir, al imprimir a en la linea 20, se llama a la dirección de memoria de a y se pide que devuelva el valor de a y luego lo saque en pantalla, con lo cual aparecerá en pantalla "5".

En la linea 30 se cambia el valor que hay almacenado en la dirección de memoria de a por el valor "10", y por ello en la linea 40, al consultar el valor de a, saldrá en pantalla el valor "10".

Esto ocurría en Basic de los primeros ordenadores, en los que solo existían dos tipos de variables:

Las que aparecían solo con letras más números eran variables enteras, eran para operaciones numéricas.

Las que aparecían seguidas del símbolo del dolar, eran variables alfanuméricas, es decir, eran como las variables de texto actuales y permitían operaciones del tipo añadir o sustraer.

10 let a$="Jocarmartom"
20 print a$
30 let b$=" siempre intenta aprender cosas nuevas"
40 print b$
50 let c$=a$+b$
60 print c$

Al poner el símbolo del dolar "$" automáticamente el interprete de BASIC reconocía el tipo de variable que se usaba como alfanumérica. De esta manera las operaciones cambiaban a ser las específicas para ello.

En la linea 50 lo que hacemos es concatenar, unir las variables a$ y b$. De esta forma lo que obtenemos es la siguiente salida en pantalla.

Joscarmartom
siempre intenta aprender cosas
Joscamartom siempre intenta aprender cosas 

[Continuará]