Esperando aprobacion

Finalmente se va a entregar el documento al decanato. Si quieres ver el documento final lo puedes ver aqui. Esperamos recibir una respuesta dentro de esta semana, confiamos en que se va a aprobar el plan y podremos empezar a organizarnos formalmente, probablemente el decanato quiera incluir sus propias ideas también.

Daré la noticia de la respuesta cuando se reciba, mientras tanto cualquiera que este interesado puede enviarme un correo y será tomado en cuenta para organizar el equipo de trabajo en cuanto recibamos el visto bueno.

Borrador del plan DesarrolladorUDB

Actualmente el plan todavía no se encuentra aprobado, pero el borrador ya se encuentra bastante avanzado y se ha discutido ampliamente con el Lic. Coto y se espera será presentado al decanato entre esta semana y la siguiente. Pueden ver el borrador actual del plan aquí.

Se tiene pensado iniciar la ejecución del plan a partir del primer ciclo del siguiente año. Por el momento se cuentan con dos proyectos piloto y un número limitado de colaboradores, pero para impulsar el plan como es debido necesitamos más gente involucrada en el proyecto.

En este momento estamos buscando miembros para el equipo de desarrollo de los respectivos pilotos. Aquellos estudiantes interesados en el desarrollo de software y que deseen hacer sus horas sociales pueden contactarme a odin.frikicoder@gmail.com. También se aceptan ideas para más proyectos pilotos, siempre y cuando estén dispuestos a respaldar sus sugerencias con apoyo como desarrolladores.

A aquellos alumnos interesados en desarrollar módulos como proyecto de cátedra para el siguiente ciclo los mantendremos informados. Por el momento los pilotos nos permiten trabajar en la materia de Programación IV, y se tiene pensado tratar de agregar un piloto para la materia de Php.

Les recuerdo que el objetivo principal de este plan va más allá de ganar horas sociales u obtener una buena nota, sino que se trata de aprender y de superarnos a nosotros mismos como desarrolladores en un ambiente similar al que encontraremos en un ambiente laboral.

Cambio de Políticas

Ha pasado ya cierto tiempo desde el inicio de este blog, y no ha progresado significativamente desde entonces.

Quiero disculparme al respecto, pero tengo que admitir que escribir tutoriales es un trabajo mucho más agotador del que cualquiera pudiera imaginar, tengo que reconocer el esfuerzo de toda la gente en toda la web que se dedica a hacer tutoriales día a día. Sin embargo, también ha fallado la propaganda que se debía de hacer al blog, y en un proyecto de este tipo el alcance es realmente importante.

Finalmente, no he podido mantener los proyectos LibTad ni Frikicoder como es debido debido a falta de tiempo y de colaboradores. Esto no me sorprende debido a que es la primera vez que inició un proyecto de esta naturaleza, y en general cualquier tipo de proyecto. Por ello he llegado a la conclusión de que ambos proyectos se cancelan tal como se conocen actualmente, esto es debido a que he preferido dedicarle todo mi tiempo y esfuerzo a un proyecto mejor organizado y con mayor apoyo dentro de mi universidad.

Por lo tanto, a partir del día de hoy, Frikicoder pasa a ser el blog extraoficial del plan DesarrolladorUDB que se esta impulsando dentro de la Universidad Don Bosco. Probablemente se seguirán publicando algunos tutoriales pero en general me dedicaré a documentar lo mejor posible todo lo relacionado con el plan para que este blog sea un punto de referencia para todo el que quiera participar.

Lamento el cambio tan drástico pero me parece que todo es para mejorar.

** TAD PILAS **

Hola a todos… primero quiero agradecer a la persona que me invito a se parte de esta vaina y espero que sirva mucho esta información, son materiales que prepare hace un par de años con la esperanza que pudieran facilitar el aprendizaje de los TAD espero que las personas que tengan contacto con estos materiales puedan utilizarlos y les facilite el estudio de los mismos, yo recopile información de muchas buenas paginas en Internet y la que mas utilice fue la “Aclamada c.conclase” excelente sitio lo recomiendo abrió para mi todo un panorama de los TAD la verdad es como mi mas grande y profunda fuente de inspiración, e hizo que el estudio de estos para mi fuera fácil y divertido porque cualquiera que antes haya trabajado con ellos no me dejara mentir en cuanto a que son un VERDADERO PASATIEMPOS y te ayudan a desarrollar la lógica de una manera sorprendente no hacen milagros... pero si te facilita el pensamiento y como que se activa la materia gris, el análisis y todas esas ondas se facilitan.

Quiero advertir que si alguien estuvo en la UDB habrán visto estos materiales pues si para aquellos que me odiaron profundamente o me apreciaron en Progra 3 y 4 “I say you Hi…. =)” son mis materiales de clases….whatever no mas palabras y la acción yo pienso estructurar la info. Así:

1- Comenzar escribiendo algunos conceptos básicos.
2- Mostrar una explicación en forma grafica.
3- Y posteriormente ejemplos de aplicación de los TAD PILA.



Obviamente esto no sera algo que este listo ya hoy...no!, sera poco a poco y obvio los comentarios son bienvenidos aunque no creo que estos cambien mi forma de pensar =) pero sientanse libres de liberar sus emociones..... ¬¬


***********************+++++++++++++++++++++++++++++++++++****************++

PILAS

Una pila es una lista ordenada de elementos en la que todas las inserciones y supresiones se realizan por un mismo extremo de la lista. A una pila se le pueden añadir y retirar nuevos nodos únicamente de su parte superior. Por esta razón, se conoce una pila como una estructura de datos LIFO por last-in, first-out, es decir último en entrar primero en salir.

Se referencia una pila mediante un apuntador al elemento superior de la misma. El miembro de enlace en el último nodo de la pila se define a NULL, para indicar que se trata de la parte inferior de la pila misma. Vea una representación gráfica de la PILA:

Note que las pilas y las listas enlazadas se representan en forma idéntica. La diferencia entre las pilas y las listas enlazadas es que en una lista enlazada las inserciones y borrados pueden ocurrir en cualquier parte, pero en una pila únicamente en su parte superior.

Las funciones primarias utilizadas para manipular una pila son push y pop. La función push crea un nuevo nodo y lo coloca en la parte superior de la pila (tope). La función pop sirve ya sea para leer o elimina un nodo de la parte superior de la pila, liberando la memoria que fue asignada al nodo retirado, y regresando el valor retirado.

Las pilas pueden implementarse con arrays pero este debe ser lo suficientemente amplio para poder contener el máximo previsto de elementos de la pila. Un extremo del array se considera el fondo de la pila, que permanecerá fijo. La implementación dinámica de una pila se hace almacenando los elementos como nodos de una lista enlazada, con la particularidad de que siempre que se quiera meter (empujar) un elemento se hará por el mismo extremo que se extraerá. Esta realización tiene la ventaja de que el tamaño se ajusta exactamente a los elementos de la pila. Sin embargo, para cada elemento es necesaria más memoria, ya que hay que guardar el campo de enlace.

Antes de analizar el código quiero advertir que en algunos casos las imagenes tienen un literal en color rojo entre parentesis o un literal encerrado en cuadrito en rojo, seguido de la imagen que contenga estos literales esta la explicación o el significado de la línea de código junto a la cual esta el literal. Es decir vean la imagen y luego la explicación para que sepan que hace cada línea de código , obviamente el programa tiene comentarios pero para entrar mas en detalle he querido colocar una explicación extra. A continuación analizaremos el código en c++ que permite implementar una pila:

Representación gráfica

La clase nodo contiene el código que permitirá crear cada nodo para implementar la pila. Cada nodo tendrá un valor (dato que se almacena dentro del nodo en la pila) y un puntero apuntando al siguiente nodo o elemento de la pila. Graficamente podriamos decir que esta clase genera una serie de cajitas que se iran uniendo unas a otras para formar la pila, estas cajitas podrian ser algo como lo siguiente:

La clase Pila encierra el código de la Pila este código permitirá crear la pila dentro de la cual se colocara cada nodo. Esta clase es la base de la pila gracias a ella sabemos donde comienza la pila y donde acaba y solamente genera un puntero que apuntará a la primera cajita de la pila si no crearamos esta clase no sabriamos donde comienza la pila. Recuerden que estamos trabajando con memoria dinamica lo que implica el necesario uso de los lindos PUNTEROS que son los responsables de decirme cual es la ubicacion de mis elementos dentro de la memoria, una memoria que no puedo controlar igual que controlo un vector, arreglo o array. Es igual pero en el vector yo digo posición 0,1,2,...n y en la memoria dinamica se asigna dinamicamente y no exactamente si mis elementos estan en la ubicación de memoria FFX001, etc. Por esto necesito saber donde comienza mi pila y luego me voy desplazando por cada nodo de la pila gracias al puntero que cada nodo tiene.

**Bueno algo enrredadito ¿no? =( al principio suena bien macabro pero despues se entiende bien esta
vaina es cuestion de practica =). Pero animo que estamos al principio conforma avancemos se facilita la
cosa. Y a medida que lo entiendan se van a sentir bien poderosos....**


...En fin graficamente la clase pila genera algo como lo siguiente:

ANALISIS DE FUNCION CONSTRUCTOR

Representación gráfica

1- El constructor inicializa el fondo de la pila, poniendo a ultimo (puntero de la pila) apuntado a NULL. Ahora ya esta creada la pila.


ANALISIS DE FUNCION PUSH (INSERTAR NUEVO NODO A LA PILA EN EL TOPE)

( A continuación se muestra la representación grafica de este segmento de código ubique el (1) y el (2) en la imagen para que sepan la presentación de estas lineas de codigo y en la respectiva explicación el significado de las mismas. )

Representación gráfica

(1) Para las pilas solo se pueden insertar elementos al tope, por lo tanto lo único que hacemos es crear el nuevo nodo pasando como parámetro el valor que guardar y pasándole el valor al que apunta en ese momento ultimo, como ultimo antes de agregar el nodo apunta a NULL entonces siguiente apuntara a NULL.
(2) Le indicamos a ultimo (puntero de la pila) que apunte al nodo que se acaba de agregar.

Bueno por hoy es todo .......continuara....

Tipos Abstractos de Datos: Introduccion

Al programar trabajamos constantemente con distintos tipos de dato en nuestras operaciones, usualmente estos tipos de dato son parte del lenguaje y tienen un significado concreto para nosotros, como por ejemplo un valor entero (int ) o un caracter (char).

La Programación Orientada a Objetos (POO) introduce el concepto de objeto como un nuevo tipo de dato, pero estos datos dejan de ser concretos y pasan a ser definidos por el usuario. Cada nueva clase es una plantilla para un objeto completamente distinto, por lo que es también un nuevo tipo de dato abstracto.

Los tipos abstractos de datos (TAD) son esencialmente, tipos de datos definidos por el usuario, usualmente a través de objetos. Sin embargo, este término se usa sobre todo para definir una colección de estructuras abstractas que suelen ser utilizadas con frecuencia. Estas estructuras, usadas adecuadamente, pueden sustituir las estructuras comunes como los arreglos y permiten la reutilización de código para resolver ciertos procesos sencillos.

El lenguaje C++ no proporciona por defecto este tipo de estructuras, por lo que estas deben ser implementadas por el programador, pero se recomienda mejor la reutilización de código utilizando las librerías STL (Librería de Plantillas Estándar) de C++ o las LibTad de su servidor, que contienen estas estructuras listas para ser simplemente implementadas. Este tipo de estructuras hacen amplio uso interno de punteros y memoria dinámica, por lo que son propensas a errores al diseñarlas, también es posible que su utilidad se vea reducida a ciertas situaciones específicas.

En los lenguajes de programación más modernos, muchas veces estas estructuras vienen incluidas dentro del lenguaje disfrazadas con otros nombres, lo que le ha dado a mucha gente la falsa impresión de que no se utilizan. Es importante sobre todo saber implementar aprender a implementarlas adecuadamente y aprovecharlas al máximo, esto simplifica muchos procesos y puede evitar algunos procesos complicados, como por ejemplo trabajar con arreglos.

Primeros pasos del proyecto Frikicoder

Tengo algunas noticias para los virtuales futuros lectores de este blog. Hace poco he creado una cuenta en sourceforge.net y estoy planeando iniciar un proyecto para diseñar las librerías para TAD's basadas en el código que he venido usando desde hace un par de meses.

Estas librerías pretenden ser completamente orientadas a objetos y más sencillas de usar que las librerías estándar de C++. En este blog se publicará la documentación necesaria para su uso, y los que quieran animarse a unirse al grupo de desarrollo de sourceforge son bienvenidos. Este será mi primer proyecto formal así que están invitados a participar todos los que tengan la voluntad, sin importar la experiencia ni los conocimientos que tengan.

Les tendré informados de más avances y pronto iniciaré una campaña de marketing y promoción del blog, así que si eres visitante y te ha gustado el sitio te invito a que dejes tus comentarios (o críticas) y si tienes la voluntad de promocionarlo tu ayuda sera bien recibida.

Sin más que agregar por el momento, se despide su blogmaster, Odin.

Operadores New y Delete

Los programas pequeños no suelen ocupar demasiado espacio en memoria, por lo que no es común preocuparse por esta y se declaran al inicio del programa todas las variables que se usaran en su ejecución. Pero cuando se trabaja con una aplicación demasiado grande y pesada esto se vuelve ineficiente porque se cargan en memoria muchos datos que no se utilizaran a menos que sea en tareas específicas.

El gasto de memoria en la ejecución de un programa puede ser controlado de muchas maneras, y una de las herramientas más útiles para un programador son los operadores new y delete. Aunque pueden ser muy confusos porque su uso se combina con punteros es posible utilizarlos de la manera adecuada si se comprende su funcionamiento y se trabaja ordenadamente. El uso de new y delete es realemente importante al trabajar con Tipos Abstractos de Datos (TAD) y permite un mejor manejo de objetos además de la creación de arreglos de diferentes tamaños en tiempo de ejecución.

Al crear variables dinámicamente la única forma de referenciarlas es por medio de su puntero, ya que no poseen un nombre de variable, y no se destruyen automáticamente al finalizar el programa. En C++ hay que borrar estos datos por medio del operador delete al finalizar su uso, aunque existen otros lenguajes que se encargan automáticamente por medio de un sistema de "recolección de basura". En un programa corto es sencillo controlar los objetos que se desecharan, pero en programas largos que implementan TAD's es fácil perder el rastro de un objeto debido a que los punteros cambian de objetivo constantemente. Para evitar estas fugas de memoria es importante organizar adecuadamente el programa y asegurarse que cada parte de su funcionamiento este debidamente aislada y documentada.

La separación adecuada de los distintos procesos de una aplicación es una práctica muy recomendable para una utilización más óptima de la memoria. Es mucho mejor utilizar las variables en el entorno de función en lugar de las variables globales, incluso es recomendable que las variables declaradas en main sean solamente las necesarias para la ejecución básica del programa, y que las funciones específicas manejen sus propias variables. Esto también da mayor robustez al código y evita que los datos se sobreescriban inesperadamente
provocando pérdida de información.

Variables y Tipos de Datos

Las variables son útiles cuando necesitamos trabajar con datos y queremos que no sean volátiles; es decir, que se conserven por un tiempo determinado, por ejemplo, mientras ejecutamos el programa.

Como programadores escribiremos varios programas para distintas situaciones, por lo tanto necesitaremos distintos tipos de datos. Muchos lenguajes de programación no necesitan definir los tipos de datos, pero siempre es mejor hacerlo porque de esa manera se sabe con lo que se esta trabajando. En C++ siempre es necesario definir el tipo de dato.

Los datos básicos se podrían definir como numéricos y alfanuméricos, pero debido a que cada variable utiliza una porción de la memoria de la computadora es importante controlar el tamaño de las variables, sobre todo las numéricas.

Los tipos de datos numéricos pueden ser específicamente para cantidades enteras o contener valores decimales. Los valores enteros simples generalmente son los que ocupan menos memoria, mientras que los datos decimales dobles o los enteros largos generalemente son los más pesados.

Los caracteres alfanumericos se almacenan solamente uno por datos, para almacenar palabras sería necesario utilizar arreglos que se verán más adelante, algunos lenguajes de programación tambien soportan tipos de datos para almacenar palabras y oraciones directamente, pero C++ no cuenta con esta función.

Finalmente existe un tipo de dato especial que solamente admite valores de verdadero o falso (0 ó 1 en su defecto) que es el tipo booleano, o también conocido como bool.

Punteros

Usualmente cuando trabajamos con una variable hacemos referencia directa al espacio de memoria reservado por medio del nombre de la variable. Esto es eficiente con variables pequeñas que se trabajaran dentro de un fragmento de código determinado, por ejemplo: la función main u otra función definida por el usuario.

Pero hay ciertas ocasiones en las que es más adecuado hacer referencia a una variable por medio de un puntero, debido a que de esta manera se pueden realizar operaciones más complejas. Un puntero es una variable especial que almacena la direccion de memoria de otra varialbe específica.

El uso de punteros puede llegar a ser muy complejo, y es el martirio de muchos programadores, pero es posible llegar a manejarlos si se comprende su funcionamiento interno. Al manejar un dato por medio de un puntero el sistema utiliza dos variables en lugar de una sola, en espacios de memoria distintos. Una es la que contiene el dato y la otra, que es el puntero, contiene la dirección de memoria de la primera; el valor del puntero puede cambiar y apuntar hacia una nueva variable sin que eso afecte en lo absoluto al dato de la primera variable.

Funciones

Hay ocasiones en las que un fragmento de código se utiliza varias veces a lo largo de un programa. Para mayor comodidad del programador se crearon las funciones, cuya principal utilidad es reutilizar fragmentos de código que se usaran varias veces o también un mayor orden en el programa.

Las funciones pueden dividirse en dos: las funciones, que retornan un valor, y los procedimientos, que no retornan nada. Aunque en la práctica resultan ser muy similares sus aplicaciones pueden ser muy distintas.

En C++ las funciones se trabajan a partir de un prototipo definido por el usuario. Ahi se define el nombre de la función que servira para llamarla en otras partes del código, los argumentos que recibirá y el tipo de dato que retornará. Es importante que el dato de retorno sea del mismo tipo que el especificado en el prototipo. Los tipos de datos también pueden ser datos definidos por el usuario.

Cuando una función no devolverá ningun dato (procedimiento) su tipo de dato se escribe como void. Estos procedimientos se utilizan sobre todo para operaciones rutinarias como imprimir en pantalla un mensaje; una función, en cambio, puede ser muchas veces parte necesaria de un algoritmo.

Arreglos

Un arreglo es una serie de variables anidadas con el mismo tipo de dato, se utilizan para manejar grupos de datos similares sin tener que declararlos uno por uno, ahorrando espacio en el código y tiempo para el programador.

Al declarar un arreglo se reserva todo el espacio en memoria necesario para esa cantidad de variables, todo en un solo bloque dividido en celdas. La variable que ha sido declarada como arreglo designa a todo ese espacio reservado, y si se quisiera accesar a una celda en especifico se tien que especificar mediante un operador, que generalmente es [].

Para recorrer el arreglo se utilizan ciclos de repeticion como for. Las cadenas de caracteres son casos especiales de arreglos que pueden ser manejados directamente en muchos casos, pero siempre es posible accesar a un caracter en especifico.

Nuevo blog de frikicoder

El proyecto frikicoder sigue adelante, sin embargo escribir tutoriales requiere mucho más tiempo del que imaginaba, y me hes imposible hacer esto y además actualizar la página. Es por eso que he decidido moverme a un blog, y aunque tenga menos libertad podré concentrarme más en los tutoriales.

Dentro de los días siguientes transferiré hacia este blog todos los tutoriales que publique en la página de geocities, probablemente con algunas modificaciones. También publicare dentro de poco la primera versión pública de mis librerías para Tipos Abstractos de Datos ( TAD ), para todo aquel que quiera utilizarlas o estudiarlas.

Mantengase pendientes para nuevas actualizaciones.