Programación profesional desde cero

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.

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.