Programación profesional desde cero | Discount Coupon for Udemy Course

Conoce qué te aportará este curso y qué alcanzarás una vez que lo termines.

Conoce detalladamente qué vas a ver en este curso y qué habilidades desarrollarás.

Descarga e instala Lazarus, la herramienta que utilizaremos para trabajar a lo largo de todo el curso.

Si usas Linux o Max debes ver estos enlaces, ya que la instalación en estos sistemas es más compleja que lo mostrado en el video.

Imprimiendo las primeras líneas de texto en la consola irás codificando tus primeros programas, comenzando a ver la esencia que hay detrás de la programación.

Las instrucciones de salida: los primeros pasos de todo programador.

Las variables, tema esencial para cualquier programa: aprende ahora a declarar una primera variable que sirva para guardar el nombre del usuario.

En la clase anterior se propone un ejercicio: pues veamos la solución paso por paso.

En esta clase aprenderás a leer datos numéricos para hacer cálculos muy simples en tu programa y mostrar el resultado al usuario.

En esta clase seguiremos aplicando lo visto hasta el momento para afianzar conceptos y aprender algunos detalles nuevos que son muy importantes. El concepto de variables es crucial, y por tanto, comprender a fondo se hace sumamente prioritario.

Un nuevo tipo de datos: el tipo Real, que permite tener números con punto flotante (con coma), como por ejemplo:

1. 3,14

2. 1,5

3. 9,1546

La cara opuesta de las variables: las constates son una herramienta muy útil para tener datos cuyo valor no cambiará a lo largo de la ejecución del programa.

En esta clase aplicaremos todo lo visto hasta el momento para realizar cálculos simples y explicar detalles a tener en cuenta a la hora de realizar tus propios proyectos.

Ya aprendiste a leer valores desde la entrada y asignarlos a una variable. Ahora aprenderás a leer datos y asignarlos a varias variables a la vez.

Es momento de comprender cómo funciona realmente la instrucción Read y su diferenciación con ReadLn.

Ahora que has trabajado con varios pequeños programas, es importante que aprendas a comentar tu código, escribiendo en lenguaje coloquial qué es lo que hacen las instrucciones de tu programa. Esta práctica es sumamente importante en el mundo de la programación, e incluso te será de utilidad a tí mismo/a cuando tengas que trabajar con proyectos grandes.

En esta clase aprenderás a utilizar la división entera (esa que enseñan en la escuela) para resolver problemas complicados. El objetivo de esta clase es esencialmente que conozcas las herramientas que Pascal (como todo lenguaje) pone a tu disposición.

Para finalizar este tema del curso, aprende algunas cuestiones sobre la lectura de caracteres.

Es hora de poner un poco a prueba todo lo visto hasta el momento y comprobar qué tanto has entendido estos temas.

La instrucción o sentencia IF te permitirá utilizar condiciones para elegir qué código debe ejecutarse en función de dichas condiciones. En esta clase aprenderás la forma más básica de esta instrucción.

Siguiendo con la condición IF, aprenderás cómo utilizar varias condiciones consecutivas para discriminar qué hacer ante varias situaciones.

Veremos un ejemplo de menú de opciones para que el usuario pueda elegir qué desea hacer con nuestro programa.

La sentencia CASE (SWITCH en otros lenguajes) permite escribir código más rápidamente cuando se requieren varios IF que distingan entre muchos caminos posibles.

A partir de ahora las cosas que pueden comenzar a hacer los programas se multiplican. Es momento de aprender a tener condiciones complejas que dependan de varios factores, y no solo de uno. El tipo BOOLEAN es esencial en cualquier lenguaje de programación, y entender su uso (entrenándote con los ejercicios) resulta clave para poder avanzar en este curso (y en cualquier otro que sea para programar).

Una extensión del uso normal que se le da a IF. Simple pero muy importante.

Es momento de poner a prueba todo lo que has aprendido sobre este tema, ya que a partir de ahora lo utilizarás siempre.

Aprende cómo funciona FOR y también cómo salir de un bucle repetitivo cuando quieras mediante el uso de BREAK.

Trabajando con la sentencia FOR crearemos un pequeño juego en el que el usuario ha de adivinar un número en tres intentos, mejorando el ejemplo visto anteriormente.

Es posible colocar una sentencia FOR (o más) dentro de otra. Esto, si bien es simple, tiene ciertas cuestiones a tener en cuenta. Aprendámoslo con ejemplos prácticos.

Mejoraremos el programa del adivinador que hemos estado implementando para que funcione de la siguiente manera:

• El usuario tendrá que adivinar un número entre 1 y 100.

• El número a adivinar será generado al azar por lo que será diferente en cada ejecución.

• Se dispondrá de un máximo de 10 intentos.

Es el mismo ejemplo que vimos en el video anterior añadiendo la generación aleatoria de números con Random y Randomize.

Es momento de poner un poco a prueba tus conocimientos de FOR.

Aplicando lo visto hasta el momento te proponemos un pequeño proyecto para mejorar el programa del Adivinador con el que hemos venido trabajando.

Sabiendo como funciona FOR estás preparado/a para conocer una nueva estructura de repetición de código: WHILE. A diferencia de FOR, WIHLE puede repetir código una cantidad indefinida de veces, dependiendo de una condición para detenerse.

La última estructura de repetición, similar a WHILE pero con pequeñas diferencias: REPEAT.

Finalizando con el tema de repetición, veremos un ejemplo práctico en el que invertiremos los roles en el juego del Adivinador: ahora será nuestro programa quién intente adivinar los números, y lo hará sorprendentemente bien.

Ahora es momento de poner a prueba lo aprendido sobre estos temas.

Es momento de conocer todos los tipos primitivos de datos que Pascal brinda. He aquí el enlace a la Web oficial:

http://wiki.freepascal.org/Variables_and_Data_Types/es

También es momento de conocer la Tabla ASCII de caracteres para poder consultarla cuando sea necesario:

http://wiki.freepascal.org/ASCII

Incursionaremos hoy en un nuevo tipo de datos, siendo el primer tipo estructurado que conocerás: los arreglos.

Ahora que sabes crear arreglos es momento de comenzar a recorrerlos. En este ejemplo crearemos un arreglo con números al azar y luego buscaremos un número ingresado por el usuario comprobando en qué posiciones del arreglo está.

En esta lección practicaremos el uso de arreglos utilizando caracteres (char).

Hasta ahora has visto como declarar arreglos estableciendo su dimensión en dicha declaración, sin embargo es posible establecer la dimensión de un arreglo en tiempo de ejecución, es decir, cuando el programa ya está en funcionamiento, tomando datos del usuario o de cualquier otro tipo de condiciones.

Ahora que sabes trabajar con arreglos lineales, es momento de trabajar con tablas o matrices.

En esta clase veremos un caso práctico en el que crearemos un arreglo de 10 celdas con números del 0 al 9 sin que ninguno se repita. Este problema, que en principio parece simple, resulta mucho más complejo de lo que se puede percibir.

En esta clase aprenderás a utilizar el depurador de Lazarus, una herramienta que te permitirá rastrear y corregir errores en tus programas, pudiendo ejecutarlos paso por paso mientras miras qué sucede con cada variable.

Esta clase es un caso de estudio práctico en el que aprenderás algunos conceptos importantes sobre la lectura de números desde la entrada estándar, la conversión de caracteres (char) a números (byte, integer, etc.), la lectura caracter a caracter mediante Read hasta encontrar el fin de línea con la función eoln, la concatenación de strings y la conversión de éstos a enteros. Es muy importante que prestes atención a todos los detalles vistos en este video ya que te serán de mucha utilidad en el futuro.

Es hora de trabajar en serio, más allá de que los ejercicios son todos potentes y exigentes, enfrentarte a un programa completo marcará la diferencia y te hará afianzar todos los conceptos vistos. En este proyecto programarás el Truco de las 21 cartas para que el programa adivine la carta que estás mirando.

Habiendo finalizado el proyecto anterior ya estás en posición de hacer frente a este reto, un proyecto que te hará aplicar en profundidad todo lo que hemos visto hasta el momento. El MasterMind es un juego de ingenio que te permitirá entrenar tu mente en niveles muy elevados.

Mejorando la versión del proyecto anterior, en esta oportunidad el programa admitirá códigos con letras repetidas. Este pequeño detalle, aunque no lo parezca, aumenta la dificultad a la hora de calcular las notas de un código (buenos y regulares), por lo cual plantea un reto interesante.

Ahora que ya sabes trabajar con arreglos, es momento de conocer una forma sencilla de recorrerlos a través de una variante de la instrucción FOR. En Pascal se conoce como FOR-IN, y en otros lenguajes como FOR-EACH.

El siguiente salto en tu capacidad como programador o programadora: los procedimientos, y posteriormente las funciones. A partir de ahora tu capacidad de creación será potenciada, y los problemas que podrás resolver con tus programas serán mucho mayores. Los subprogramas te permiten dividir un problema grande en problemas más pequeños que puedan resolverse de manera más sencilla. Al unir luego todas las soluciones pequeñas, el problema original se resuelve también.

Sabiendo crear procedimientos para realizar tareas independientes del programa principal, es momento de poder pasar información a dichos subprogramas para hacer lo que necesitas.

Las funciones son esencialmente iguales que los procedimientos, salvo que ellas devuelven un resultado al finalizar su ejecución (como lo hace por ejemplo la función RANDOM) y los procedimientos no.

La definición de identificadores para variables, constantes, tipos y hasta subprogramas toma ahora un nuevo significado, ya que lo que existe en un subprograma no se ve hacia fuera de éste, pero lo que está fuera sí es visible dentro.

En este ejemplo práctico mostramos cómo crear y utilizar una función booleana que sirva en las condiciones de un IF, WHILE o REPEAT.

Este concepto marca un siguiente quiebre en el dominio de la programación y en el suso de subprogramas. El pasaje de parámetros por referencia es de vital importancia y suele ser tema de dificultad. Esta clase requiere atención, ya que el concepto en sí es simple.

Un subprograma puede llamar (invocar) a cualquier otro subprograma que esté disponible (incluso a sí mismo). Esto es muy útil, sin embargo tiene algunos detalles a tener en cuenta.

En esta clase veremos algunos ejemplos prácticos para que los conceptos dados hasta ahora se comprendan bien.

La sobrecarga es la capacidad de un lenguaje de permitir que un mismo identificador se utilice para varias operaciones (o subprogramas), entre otras cosas. Aprende aquí cómo utilizar esta capacidad a tu favor.

Esta actualización del proyecto tendrá menor dificultad que las anteriores pero aún así será retadora. El programa será reescrito utilizando procedimientos y funciones (nosotros te daremos ya sus cabeceras) y además controlará errores en el ingreso de códigos por parte del usuario.

Entrando en el nuevo tema comenzaremos aprendiendo acerca del tipo enumerado.

En esta clase veremos un ejemplo práctico de aplicación de los enumerados en el programa del Adivinador, utilizando dicha herramienta para programar la dificultad del juego.

Es momento de aprender uno de los tipos más poderosos de Pascal, precuela a la Programación Orientada a Objetos (aunque estamos lejos de ella). Los Registros permiten definir tipos de datos complejos y con mucha funcionalidad. Son la base para el próximo salto en tu capacidad como programador o programadora.

Aplicando lo visto hasta ahora, en este ejemplo práctico modificaremos el programa del Adivinador para utilizar Enumerados, Registros y subprogramas, mejorando el diseño.

Utilizando arreglos (array) y registros (record), es posible implementar un arreglo que guarde diferentes cantidades de elementos, pudiendo incluso agregar o quitar elementos.

En este video te presentamos la nueva versión del MasterMind en donde los roles se invierten: Ahora tu programa intentará adivinar un código que tú pienses, recibiendo él las notas e intentando acertar a lo que tú has pensado.

En esta clase aprenderás cómo utilizar unidades (units) para separar el código de tu programa en diferentes archivos.

Finalizando con el Proyecto MasterMind, en esta oportunidad simplemente unirás las dos versiones que ya programaste en una sola, contando además con una sencilla interfaz gráfica ya programada por nosotros, para que el juego se vea un poco mejor que el simple texto de la consola.

El Juego de la Vida, de John Conway, es uno de los modelos de simulación celular más básicos y a la vez interesantes que existen. A lo largo de 4 clases trabajaremos con este proyecto para programar su funcionamiento, mostrando conceptos muy importantes y básicos de la programación. Aplicaremos todo lo visto hasta el momento en el curso y mostraremos la forma en que deberás llevar a cabo tus proyectos finales.

Continuando con la segunda parte de este caso de estudio, veremos en este video la estructura que tiene el programa y cuáles son las partes que tú como estudiante de este curso tendrás que implementar para darle funcionalidad.

Continuando con el video anterior, en esta clase programaremos dos de las operaciones del juego: init, para inicializar el tablero y los demás atributos, y getCelulasVivas, para contar la cantidad de celdas activas alrededor de una posición dada.

En esta clase finalizaremos el proyecto del Juego de la Vida implementando las operaciones que faltan.

En esta clase te presentamos el proyecto final de este módulo, el clásico juego Buscaminas, que te presentará varios retos como programador/a y que además te hará aplicar todo lo que hemos visto en el curso hasta el momento.

En esta clase conocerás los aspectos básicos sobre archivos de texto plano y crearás tu primer fichero en el disco duro.

En esta clase aprenderás a CREAR, LEER, MODIFICAR y COPIAR archivos.

Crearemos en esta clase un programa con varias opciones, cada una de las cuales nos permitirá aplicar un concepto distinto, para abarcar todo lo necesario sobre archivos de texto, que luego extenderemos a archivos con tipo, profundizando al máximo.

Crearemos juntos un procesador de textos básicos estilo "Bloc de notas" que permita:

• Crear archivos nuevos

• Abrir y modificar archivos existentes

• Usar Guardar como...

Haremos uso de una interfaz gráfica ya programada y nos encargaremos de darle funcionalidad.

Es momento de conocer los archivos con tipo y aprender a escribir y leer datos de ellos.

Archivos con tipos de datos primitivos pueden ser útiles, pero no explotan ni por asomo el potencial de los archivos. En esta clase aprenderás a declarar archivos con tipos de datos definidos por ti usando el tipo RECORD y PACKED RECORD.

Usando todo lo aprendido sobre archivos, crearemos un programa que nos permita gestionar una "base de datos" bien simple, donde podamos leer, modificar, crear y eliminar registros.

Ahora que sabes crear y modificar registros en un archivo, es momento de aprender a eliminarlos, cuestión que no es tan simple como puede parecer en un principio. En esta clase veremos dos formas de lograr este cometido:

1. Crear una copia del archivo original omitiendo los registros a eliminar y luego renombrar el archivo temporal eliminando el original, tal como hicimos con el sistema NotepadPas.
   

2. Dejar el registro en el archivo, pero marcarlo como ELIMINADO para que el resto de nuestro sistema lo omita cada vez que pase por él.

Existe una tercera forma que permite liberar el espacio de un registro dentro de un archivo tipado, pero solo cuando dicho registro está al final, mediante TRUNCATE, pero no la veremos en este curso porque no resulta muy útil en la vida real.

Este proyecto es relativamente sencillo respecto a proyectos anteriores, aunque no dejará de ser un reto. Programarás un sistema de base de datos simple que funcionará mediante un sistema de comandos, agilizando el ingreso de datos. Aplicarás todo lo visto con archivos hasta ahora.

Comenzaremos por fin a trabajar con la memoria dinámica utilizando el tipo puntero de Pascal para poder solicitar y liberar memoria cada vez que queramos. En esta clase aprenderás a declarar un puntero a cualquier tipo de datos, pedir memoria, acceder a ella, y liberarla cuando ya no la necesites. También entenderás cómo Pascal gestiona este recurso y cómo es que tu como programador haces uso de él.

Pudiendo crear tus propios tipos de datos, como registros, puedes crear punteros a esos datos y pedir memoria para ocuparla cuando quieras. En esta clase aprenderás a tener punteros de tipo RECORD y verás el concepto de ALIAS (dos punteros apuntando al mismo lugar), y todo lo que esto conlleva:

• Modificar el dato desde un puntero afecta al otro

• Crear nueva memoria deja de aplicar alias

• Liberar a un puntero también libera a su alias y lo deja indefinido

Las Listas Enlazadas o Listas Simples Encadenadas (Linked List en inglés), son una estructura lineal (como lo son los arreglos unidimensionales) que pueden crecer y decrecer dinámicamente; dicho de otro modo, en tiempo de ejecución (mientras tu programa está operando), la estructura puede pedir memoria y crecer, o bien, liberarla y decrecer.

En esta clase aprenderás cómo crear listas encadenadas simples utilizando punteros como herramienta para solicitar memoria.

Ahora que conoces las listas encadenadas (enlazadas), es momento de ver las posibles situaciones a la hora de agregar nuevos nodos:

• Al inicio de la lista

• En un punto entre dos nodos

• Al final de la lista

Cada caso tiene sus cuestiones particulares, pero no es algo demasiado complicado. Sin embargo es importante que lo veamos detenidamente para que comprendas a fondo qué se está haciendo.

Ahora que sabes recorrer una lista y agregar nodo en ella, es momento de aprender a eliminarlos.

Tomaremos el programa Notepad Pas que realizamos anteriormente y modificaremos su uso de memoria estática con arreglos con tope por memoria dinámica con listas encadenadas.

Es necesario que apliques todo lo aprendido hasta el momento. Esta sencilla pero retadora propuesta te hará interiorizar y aprehender absolutamente todo lo relacionado a punteros, memoria dinámica, listas encadenadas e incluso funciones y procedimientos.

ES DE CARÁCTER OBLIGATORIO y se esperará que entregues tu trabajo.

Trabajar con memoria dinámica es propenso a muchos errores en tiempo de ejecución, los cuales aparecen muchas veces en caso concretos, que no son detectados hasta que es muy tarde. En esta clase conocerás el concepto de test de estrés (stress testing), con el cual llevaremos a nuestro programa al límite, e incluso más, buscando que éste caiga. Si el test pasa, entonces consideramos que la robustez del programa es correcta.

Si bien ya echamos un vistazo a las unidades en pascal (unit) y a cómo éstas permiten dividir un programa en varios módulos independientes, lo hicimos de una forma muy superficial. Ahora es momento de que aprendas realmente a trabajar con módulos, definir los tuyos propios y aplicar el concepto de Tipos Abstractos de Datos.

Es momento de formalizar este concepto con el cual has venido trabajando desde hace tiempo. Entender qué es un TAD te permitirá comenzar a diseñar tus propios programas. En esta clase crearemos desde cero dos Tipos Abstractos de Datos y además implementaremos todas sus operaciones paso por paso.

Comprenderás el concepto de Expresiones Regulares y cómo esta herramienta te permitirá trabajar con cadenas de caracteres (Strings) de forma mucho más simple, robusta y fluida.

Inicia aquí una serie de clases que dedicaremos a diseñar e implementar desde cero, en Pascal, un sistema de gestión de un centro educativo, siendo un programa bastante básico en su ejecución pero complejo en su creación.

En esta clase presentaremos el proyecto en funcionamiento y además podrás (y deberás) descargarte el documento que lo describe a fondo ya que será necesario para el desarrollo de las clases posteriores.

A través de este proyecto profundizaremos en varios temas del curso e introduciremos conceptos nuevos de vital importancia para pasar al paradigma de Programación Orientada a Objetos.

Introduciremos en esta clase un concepto totalmente nuevo: DISEÑO de Software. Si bien lo haremos de manera simple y sin ir demasiado a fondo, esta será una clase con mucho contenido, y que te irá preparando como programador/a a un nivel mucho mayor que el simple hecho de conocer un lenguaje concreto.

Definiremos así las entidades que deberán existir en nuestros sistema, su base de datos o estructura de persistencia, y cómo dichos datos se relacionarán entre sí.

Habiendo diseñado  el sistema y comenzado con la estructura de módulos independientes, en esta clase le daremos código a esos módulos a fin de queden funcionales y listos para pasar a la siguiente etapa.

El concepto de colecciones ha sido tocado ya en el curso en diversas oportunidades pero de forma implícita, ahora es momento de verlo explícitamente y comprender a fondo cómo funciona el asunto de tener grupos o estructuras de ciertos tipos de datos.

Teniendo el diseño listo y la estructura de las colecciones que implementaremos en nuestro sistema, es momento de darles funcionalidad, para poder avanzar en la siguiente etapa del desarrollo de este software.

Habiendo cumplido con las dependencias previas, es momento de diseñar y programar los gestores de mensajes (salida del sistema) y formato. Si bien esto no es complejo, es de suma importancia comprender cómo se diseña de manera tal que sea simple y a la vez potente.

Desde el diseño conocemos hace tiempo las estructuras que existirán en la base de datos y cómo se relacionarán a través, justamente, de un diseño relacional. Es momento de escribir el código fuente que le dará funcionalidad a esta estructura y permitirá que el programa guarde los datos y los lea, manteniendo las relaciones en todo momento.

El módulo que se encarga de gestionar todo, de unir a los módulos anteriores en un trabajo que permita ejecutar todo lo que el programa debe hacer y además interactuar con el usuario. Sin duda, todo un reto por programar. Finalmente, para que el sistema funcione, es necesario implementar el programa principal, es decir, el archivo con el bloque BEGIN|END que es donde la ejecución inicia, la puerta de entrada.

Retomamos el concepto de TAD propiamente dicho, volviendo a analizar lo que es una lista encadenada simple, pero ya desde una propuesta más teórica y, a la vez, práctica. Tendrás que hacer un ejercicio muy interesante en esta clase, el cual deberás entregar. El archivo ZIP de recurso tiene la letra del ejercicio y el código fuente que necesitas.

En esta clase finalizaremos con el Tipo Abstracto de Datos Lista Encadenada, conociendo además sus variantes: lista circular, lista doble encadenada, lista doble encadenada circular, lista con indexado implícito y lista con indexado explícito. Además conocerás el concepto de celda falsa o dummy. Luego, por supuesto, tendrás que cumplir con algunos ejercicios obligatorios para entrenarte en estos conceptos y avanzar al siguiente tema.

Es momento de conocer dos estructuras muy simples pero poderosas, basadas en Listas Encadenadas: las Pilas y las Colas. Conociendo estas estructuras, tu nivel como programador/a aumentará muchísimo. Es habitual encontrar cursos on-line donde no se habla absolutamente nada de esto. Por supuesto, tendrás que implementar tú estas estructuras como ejercicios.

Ya casi finalizando esta sección del curso, es momento de dejar las estructuras lineales y pasar a las arborescentes a través del Árbol Binario, concretamente utilizando el Árbol de Búsqueda. Esto es un cambio radical en el uso de estructuras dinámicas ya que posee una complejidad bastante alta, siendo la precuela a la necesidad de utilizar recursividad para solucionar ciertos problemas.

En esta clase veremos puntualmente cómo se elimina un nodo de un árbol binario de búsqueda, teniendo en cuenta los posibles casos a la hora de hacerlo. Es una clase muy importante por lo cual es sumamente necesario que profundices en ella y logres entender a fondo lo que se hace.

Descarga aquí el proyecto que debes hacer y ENTREGAR para esta sección, siendo OBLIGATORIO.

El primer paso es ver algunos ejemplos de recursividad directa para que entiendas de qué se trata esto, qué cosas hay que tener en cuenta, y los posibles problemas a los que te puedes enfrentar.

Si entiendes el concepto que explicaré aquí, entenderás la recursión a fondo y no resultará algo tan difícil para ti.

En esta clase aprenderás a definir clases de objetos (class) en Pascal Moderno, dando un salto cuántico en tu forma de programar, convirtiéndote en un/a programador/a robusto/a, con un abanico amplio de herramientas de las qué disponer. A partir de ahora, nada podrá hacerte frente ni interponerse en tu camino.

En esta oportunidad profundizaremos un poco más en el concepto de clases en Pascal y la nueva sintaxis así como el nuevo paradigma de trabajo que comenzaremos a adoptar de ahora en más.

Los componentes de tus clases pueden determinar cómo se accede a ellos. Conoce los modificadores PUBLIC, PRIVATE, y algo superficialmente por ahora PROTECTED (al ver herencia lo entenderemos a fondo). Es momento de comenzar a estructurar tus clases de manera sabia y correcta. Esto nos permite ir entrando en el concepto de encapsulamiento.

El uso de clases tiene sus particularidades, siendo importante comenzar a comprenderlas desde ahora. En este video comenzaremos a implementar el TAD Lista Encadenada Simple utilizando clases de Pascal. Introduciremos así el concepto de Clases Internas y analizaremos las cuestiones inherentes al nuevo paradigma de programación.

Los clientes de una clase (o un tipo) son quienes hacen uso de ella (o él). Debemos implementar operaciones que permitan recorrer la lista desde fuera de la clase en que es definida, y eso haremos aquí con algunas primitivas esenciales. Es importante que entiendas esto ya que te entrenará correctamente en el uso de POO y te preparará para todo lo que está por venir.

Las estructuras que almacenan datos, tales como arreglos, listas encadenadas y árboles, entre otras, se conocen como colecciones, ya que "coleccionan" varios datos de un mismo tipo. Veremos en esta clase como generar un contenedor de desplazamiento para automatizar el proceso de recorrido de una estructura, en este caso una lista encadenada, y lograr que Pascal detecte ésto para usarlo en un bucle FOR-IN.

NOTA: Habrá un error en la implementación vista en este video, el cual será explicado y pedido como proyecto en el recurso que podrás descargar.

Las propiedades (property) son una herramienta muy útil en Pascal, que agiliza el tiempo de desarrollo y codificación, generando además un código mucho más elegante y legible. Es una alternativa a los típicos GETTER y SETTER de todos los lenguajes, que no he visto en ninguna otra tecnología. Su uso es sumamente simple y fácil de aprender, por lo cual lo presento en esta clase.

Aplicando lo aprendido hasta ahora en POO, reprogramaremos el pequeño juego del Adivinador unificando ambos modos (adivinador y pensador) en uno, utilizando ahora clases y objetos.

En la clase anterior definimos el programa Adivinador 5.0 utilizando POO, pero no implementamos el controlador del mismo para que funcionara. Eso haremos en esta clase, teniendo en cuenta algunas cuestiones interesantes, como directivas del compilador y el uso de parámetros opcionales en operaciones.

Dejo aquí el enlace a la página oficial de las directivas de FreePascal para quién quiera explorarlas:

https://www.freepascal.org/docs-html/prog/progch1.html

En esta clase primero repasaremos las diferencias entre el modelo antiguo de objetos utilizando punteros y el modelo de clases, para luego introducir un nuevo concepto: los campos estáticos. Es un tema que debes comprender a la perfección si quieres programar orientado a objetos.

Utilizando lo aprendido en la clase anterior sobre componentes estáticos de una clase, aprenderás aquí a utilizar un patrón de diseño de objetos llamado SINGLETON, que entre otras cosas, garantiza que solo se pueda crear una única instancia de una clase (objeto) y no más.

En esta clase te presento un proyecto muy interesante que te hará trabajar arduamente aplicando absolutamente todo lo que has aprendido a lo largo del curso, y por supuesto haciendo énfasis en la POO. Se trata de llevar adelante toda la lógica del juego de la Batalla Naval o BattleShip.

En esta clase iniciarás a ver lo que es la Herencia en Programación Orientada a Objetos y cómo esta te abre un abanico nuevo de posibilidades.

La herencia no sirve solo para reutilizar código, sino que su poder se comienza a manifestar con la conversión de tipos y el casteo de objetos.

Las interfaces son una herramienta avanzada y crucial de la Programación Orientada a Objetos ya que, entre muchas otras cosas, permiten la herencia múltiple y la definición de tipos de datos a ser utilizados por cualquier clase que utilice la plantilla que una interfaz define.

Ahora que conociste lo que es una interfaz, es momento de ver un uso más avanzado de esta herramienta para luego implementar una colección de objetos basándonos en ella.

Definimos una interfaz para guardar en un árbol binario de búsqueda elementos de ella. De este modo, podrás guardar en dicho árbol cualquier objeto de cualquier clase que implemente dicha interfaz.

En esta clase aprenderás qué es el polimorfismo de operaciones y con ello el uso de las palabras reservadas virtual, override y overload.

Otra útil herramienta que la POO provee para ampliar las opciones de desarrollo de software. Es importante que comprendas este concepto a fondo para consagrarte como programador/a profesional.

En esta clase te presentaré el proyecto obligatorio que debes hacer para aplicar al máximo todo lo visto en el curso, incluyendo Herencia, Polimorfismo, Interfaces y Clases abstractas. Te lo presentaré con un diseño UML para que aprendas dicha herramienta y resulte en un reto traducir un diagrama de diseño a lenguaje Pascal.

Los genéricos son una herramienta avanzada de la POO que facilita muchísimo el uso de colecciones y tipos de datos inespecíficos, pensando estructuras que luego podrán ser usadas por casi cualquier objeto. Todo lenguaje moderno hoy día soporta esta herramienta, y Pascal no es la excepción.

Pascal provee de varias colecciones genéricas ya implementadas y optimizadas, como Listas, Pilas, Colas, Árboles y Tablas, entre otras, listas para facilitarte la vida.

Capturar excepciones en tiempo de ejecución es algo crucial en todo lenguaje moderno. Así como Java tiene, por ejemplo, los bloques try...catch, pascal provee de un mecanismo similar que te permitirá entrenar en el uso de este tipo de herramientas, siendo éste el uso de bloques TRY..FINALLY y TRY..EXCEPT.

Sabiendo capturar excepciones es momento de que sepas lanzar tus propias excepciones, sean predefinidas o personalizadas. En lenguajes como Java o C++ se hace mediante la sentencia trhow, en Pascal lo harás usando raise.

Comenzarás a utilizar la librería de Lazarus conocida como LCL (Lazarus Component Library) para crear aplicaciones con interfaces gráficas de usuario. En esta oportunidad construirás nuevamente el programa "HolaMundo" pero usando una ventana con un botón y un evento de click.

En esta clase aprenderás cómo hacer que tu ventana no pueda cambiar de tamaño ni maximizarse, así como trabajar con un campo de texto para obtener información del usuario y detectar las teclas presionadas.

Siguiendo con el uso de botones, etiquetas y campos de texto, en esta clase crearemos un formulario muy básico para pedir algunos datos al usuario y hacer algo con ellos. También aprenderás cómo crear un botón para salir así como a limpiar los campos automáticamente.

En esta clase mejoraremos el formulario creando eventos de foco para validar los datos ingresados en tiempo real.

Seguiremos trabajando con el formulario pero esta vez agregaremos íconos para mostrar cuando hay o no hay errores así como un área de texto para visualizar los resultados. También utilizaremos el evento de inicialización de una ventana para poder hacer cosas previas a la ejecución de la misma.

En esta clase haremos desde cero un formulario completo para que repases todo lo visto y añadiremos el uso de campos de contraseña, botones de radio para brindar opciones de una sola elección y cajas de check para múltiple opción. Además verás algunos aspectos del uso de eventos que resultará importante dominar.

Conocerás cómo utilizar una lista desplegable (ComboBox) tanto para saber qué elemento de ella se ha seleccionado así como para poder agregar elementos dinámicamente en tiempo de ejecución. También te mostraré cómo usar un botón con ícono para tus programas.

A diferencia de un ComboBox, un ListBox es una lista no desplegable que además admite selección múltiple de elementos. Aprenderás cómo utilizarla para determinar los elementos seleccionados en ella así como para agregar elementos de forma dinámica.

Hasta ahora hemos utilizado ShowDialog para mostrar cuados de diálogo muy básicos ya que solo sirven para mostrar un mensaje al usuario. Es momento de poder hacer preguntas y detectar qué opción se eligió para hacer algo al respecto, para lo cual usaremos diálogos un poquito más personalizados.

En esta clase te mostraré cómo usar diálogos para seleccionar archivos y también para guardarlos.

Una aplicación compleja contiene muchas VISTAS, es decir, varias ventanas y/o cuadros donde mostrar y solicitar información al usuario. En esta clase te mostraré cómo agregar ventanas nuevas y cómo configurarlas como cuadros de diálogo si fuese necesario.

En esta clase aprenderás algunas cuestiones de contenido, agregar varios paneles a una ventana, gestionarlos y dividirlos de forma ajustable, así como a crear pestañas de contenido.

Es hora de añadir elementos de menú a tus aplicaciones. En esta clase verás cómo añadir una barra de menú y cómo crear menús contextuales para asociarlos a tus componentes y hacer que aparezcan al presionar el botón derecho del mouse.

En esta clase aprenderás a manipular tablas de datos, tanto para agregar y borrar filas, como para detectar la selección que el usuario hace dentro de una tabla.

Mostrar imágenes en la interfaz gráfica puede ser sumamente útil, así que veremos algunas cuestiones básicas para que puedas crear programas más vistosos e intresantes.

Muchas veces se requiere generar componentes visuales acorde a ciertos datos en tiempo de ejecución, por lo cual no es posible crearlos en tiempo de diseño. En esta clase te daré las pautas para generar dinámicamente componentes visuales. Además aprenderás a usar un temporizador (timer) para ejecutar bucles periódicos en hilos paralelos y gestionar tareas que no pueden hacerse en el hilo principal.

El uso de acciones permite estructurar nuestras aplicaciones de una forma mucho más eficiente, corta y prolija que si lo hacemos todo con eventos. En esta clase te mostraré cómo las acciones te facilitan la vida como no tienes idea, además aprenderás a usar barras de herramientas y listas de imágenes.

Lograr que la información de una tabla con muchos datos pueda filtrarse según lo que el usuario necesita ver es algo mu poderoso.

Te presentamos un proyecto simple pero interesante para crear una GUI sencilla de una calculadora básica. Tienes que lograr generarla por tu cuenta con todo lo dado en el curso hasta ahora.

Para consagrarte como programador/a propiamente dicho/a es necesario que crees desde cero tu propio software, aplicando absolutamente todo lo visto en el curso, con interfaz gráfica, persistencia, y todo. En esta clase te explicaré cómo debes comenzar con la presentación de tu tesis y la forma en que iremos llevándola a cabo hasta su consecución y defensa final.