¿Con qué lenguaje aprender a programar?

Revisando algunas cosas en mis videos me encontré con esto:

Este video lo hice hace aproximadamente un año y estaba dirigido más que nada a gente que todavía no programa, no tiene idea de que va la programación y que pregunta siempre ¿Con qué lenguaje empiezo a programar? salteandose varios pasos.

Lo peor es que mucha gente responde con un lenguaje (generalmente su favorito) lo cual constituye a mi modo de ver un pésimo consejo, ya que la persona va a meterse en el lenguaje sin terminar de comprender qué es lo que está haciendo y esto tiene un motivo:

La persona que empieza por el lenguaje empieza por empezar a conocer como funciona una herramienta sin saber para qué sirve esa herramienta. Esto puede ser frustrante de esta manera ya que dificilmente pueda resolver problemas con la herramienta dada.

Lo primero que debe hacer una persona que quiere programar es entender sobre lógica de programación, algoritimia, resolver problemas, entender estructuras de datos independientemente de un lenguaje que quiera usar.

Lo segundo que el principiante omite al preguntar por donde empezar es qué es lo que quiere programar. Hoy por hoy, programar es algo muy amplio, no es lo mismo querer programar microcontroladores que sistemas de gestión, una web o lo que fuere.

Este punto, claramente incide en el tipo de lenguaje a aprender ya que los propósitos de los lenguajes son distintos y cada uno tiene uno o más puntos fuertes.

Y aquí viene el tercer punto. Elija lo que quiera hacer, elija el lenguaje que elija, el entender las bases de la programación independientemente del lenguaje a utilizar hace que el aprendizaje sea mucho más sencillo, porque si sé que quiero hacer y dado el problema que quiero resolver elijo la herramienta (lenguaje, librerías, etc.) adecuada, entonces lo que quiera aprender de código en si mismo se va a reducir a aprender sintaxis.

En resumen, a veces el camino más largo es el mejor. Aprender a programar no es lo mismo que aprender un lenguaje y cuando uno entiende que quiere hacer porque tiene bases sólidas, el resto se vuelve mucho más trivial.

Leyendo archivos en Java

Muy bienvenidos a mi hermoso blog (debería escribir más seguido). En esta ocasión ver como leer de manera sencilla un archivo que tengamos linea a linea.

Lo primero que vamos a necesitar es nuestra clase encargada de leer el archivo, la cual vamos a llamar para el ejemplo LeerArchivos y a la cual le vamos a dar un método llamado leer.

public class LeerArchivos{
     public void leer(){}
}

Ya tenemos la clase, ahora tenemos que ir solucionando problemas uno a uno. Vamos a ver entonces primero en donde poner el texto del archivo ya leido. Para almacenar el texto vamos a usar un StringBuilder (No vamos a usar un String común ya que estos son inmutables, para más detalles, vean el video, pero algún día vamos a hablar de esto a fondo).

StringBuilder sb = new StringBuilder();

El siguiente problema es buscar el archivo, para esto vamos a usar Path y Paths. Básicamente lo que necesitamos es un path donde está nuestro archivo y este lo sacamos de usar Paths.get() (Que nos va a devolver el Path que necesitamos)

Path filePath = Paths.get("ruta del archivo\\archivo");

Notese que uso doble barra ya que en un String, las barras sirven para distintos tipos de escape (Por ejemplo \n significa salto de linea) y cuando quiero poner una barra en el texto necesito poner otra que la preceda.

Ya con el lugar donde vamos a depositar el texto leido y que archivo vamos a leer necesitamos el mecanismo que lea, para esto vamos a usar un objeto de tipo BufferedReader. Esto sirve básicamente para leer de algún tipo de input, en este caso de un archivo. Para leer de un archivo vamos a hacer esto:

BufferedReader br = Files.newBufferedReader(filePath);

Como abrir un archivo para su lectura es algo que puede traernos cantidades de excepciones, se nos va a requerir un bloque try/catch, con lo que nuestro código pasaría a ser algo así:

try{
    BufferedReader br = Files.newBufferedReader(filePath);
} catch(IOException e) {
    e.printStackTrace();
}

Después dejen lindo el try/catch a gusto, pero a priori esto sirve.

Ahora que ya tenemos esto, vamos pasando linea a linea nuestro texto al StringBuilder

String linea;
While((linea = br.readLine()) != null) {
     sb.append(linea).append("\n");
}

Si esto los marea les explico: En mi While, le digo que el ciclo va a repetirse leyendo una linea y sumándosela a la variable linea y se corte si eso da null, lo cual es como un «se terminó el archivo y no hay nada más que leer».

Dentro del While voy a ir agregando lo que se lee y se pasa a la variable linea y un \n para hacer el salto de linea.

Con esto ya tenemos nuestra clase de lectura de archivos que quedaría en definitiva así:

public class LeerArchivos{
     public void leer(){
         StringBuilder sb = new StringBuilder();
         Path filePath = Paths.get("ruta del archivo\\archivo");
         try{
              BufferedReader br = Files.newBufferedReader(filePath);
              String linea;
              While((linea = br.readLine()) != null) {
                   sb.append(linea).append("\n");
              }
         } catch(IOException e) {
              e.printStackTrace();
         }
    }
}

Con lo que si quieren ver como funciona, solo deben crear una clase main, poner dentro un objeto de tipo LeerArchivo y ejecutar nuestro método leer:

public class Principal {
     public static void main(String[] args){
          LeerArchivo leerArchivo = new LeerArchivo();
          leerArchivo.leer();
     }
}

Y esto es todo por hoy, espero que les haya servido.

QBasic con QB 64, Capítulo 1: Hola Mundo

Para ir arrancando con este blog, voy a poner algo que me apasiona, que es la «retro programación». ¿Y qué es eso dirán? La respuesta es simple: un poco de nostalgia. Cuando yo arranqué a programar (fines del 95, principios del 96), lo primero que veías luego de entender un poco de algoritmia era QBasic, porque supuestamente era sencillo (vamos a volver sobre el tópico «sencillo» dentro de un tiempito y mostrar que no lo es tanto) y era ideal para comenzar. Con el tiempo, el gustito por QBasic siempre me quedó, aún cuando pasé a lenguajes más «serios» (En esa época lo que daba de comer era Clipper). Hace unos años quise volver sobre mis pasos y hacer de la retroprogramación un pasatiempo, y me encontré con una joya digna de ser mencionada: QB64.

Muchos de los más jóvenes probablemente no tienen ni la menor idea de que es QBasic, pero creanme que en una época era el lugar común para dar los primeros pasos en la programación. De hecho en mi adolescencia/principio de la adultez jugé infinidad de horas con esto y le dediqué más tiempo que a los videojuegos en mis momentos de ocio (lo cual no quiere decir que vicié feo con cosas como Monkey Island).

Pasando al tema del post (como siempre me voy por las ramas), empecemos a ver como funciona QBasic:

Básicamente lo que vamos a lograr en este post es instalar QB64 y hacer nuestro «hola mundo».

El primer paso consiste en bajar el instalador del sitio oficial de QB64 donde van a ver un botón que dice «Download». Una vez que lo presionen los va a llevar a un sitio de github (no se preocupen, no tienen que clonar nada) donde están los links de descarga dependiendo del sistema

Elijan el que se adapte a su SO.

Una vez que lo tienen, simplemente descomprimanlo con el programa que tengan (winrar o lo que sea) en la carpeta que les venga bien y listo, solo deben buscar el ejecutable.

Una vez tienen el «IDE» abierto ya pueden empezar con el código!!!! Por supuesto, vamos a empezar por el típico «Hola Mundo». Simplemente tenemos que escribir:

PRINT "Hola Mundo"

Y al presionar F5 (y guardar el archivo), la magia ocurre:

Hola Mundo

El próximo paso es poder escribir algo en una variable e imprimirla:

INPUT "Ingrese su nombre: ", nombre$
PRINT "Su nombre es: "+nombre$

Ya podemos controlar el uso de variables!

Y con esto ya tenemos nuestro entorno QBasic con QB64 terminado.

Espero les guste tanto como a mí la retroprogramación, QBasic, el código y viva la programación!