Cualquiera puede aprender a programar si se lo propone. Cada día estamos constantemente programando, solo que en nuestro propio lenguaje natural.

Puedes aprender a usar un lenguaje de programación y construir código, y tal vez encontrar un trabajo en esto; pero si realmente quieres ser bueno, eso no va a ser suficiente.

En el mundo de la programación a veces no entenderás absolutamente nada y eso tiende a desanimarnos; solo hay que seguir intentándolo hasta tener éxito.

Luego de haber tenido la oportunidad de ir a la universidad, de seguirme formando a través de cursos en línea y de trabajar en el área de la programación por varios años, hoy quiero hablarte de 5 puntos que según mi experiencia vas a necesitar estudiar antes de aprender a programar.

Esos puntos son:

1. Lógica.
2. Algoritmos.
3. Variables, estructuras de control y funciones.
4. Bases de datos.
5. Control de versiones.

Ahora te resumo de qué se trata cada uno:

1. Lógica:

La lógica nos enseña a pensar de forma distinta, de forma más cercana a la máquina que al cerebro humano. Por suerte en la actualidad no tenemos que ir al centro de todo que son los ceros (0) y unos (1), el real lenguaje de las computadoras. Pero si debemos tener presente la lógica para enunciar instrucciones para la computadora.

Esta lógica se conforma de algo llamado valores de la verdad. Existen dos valores posibles: Verdadero y Falso.

• ¿Mi color favorito es el verde?: Verdadero.
• ¿Mi color favorito es el amarillo?: Falso.

Luego esos valores se conectan a través de conectores lógicos conocidos como conjunción (y), disyunción (ó) y negación (no).

• ¿Mi color favorito es el verde y el amarillo?: Falso.
• ¿Mi color favorito es el verde ó el amarillo?: Verdadero.
• ¿Mi color favorito no es el verde?: Falso.

Para entender el tema con más detalles, conseguí este enlace que les puede servir de introducción.

2. Algoritmos

Un algoritmo es un conjunto de instrucciones para resolver un problema. Para crear un algoritmo debemos ser capaces inicialmente de analizar el problema planteado y sus posibles soluciones.

Por ejemplo, ¿cómo enviar un correo electrónico desde Gmail?

• Paso 1. Ingresar www.gmail.com.
• Paso 2. Ingresar usuario y contraseña.
• Paso 3. Hacer click en el botón Redactar.
• Paso 4. Ingresar el Destinatario.
• Paso 5. Ingresar el Asunto.
• Paso 6. Ingresar el cuerpo del correo electrónico.
• Paso 7. Hacer click en el botón Enviar.

Debes escribir muchos algoritmos, ya sea en lenguaje natural, pseudocódigo o diagramas de flujo. Entre más algoritmos escribas, más desarrollarás la destreza necesaria para solucionar diversos problemas.

El algoritmo que en mi caso me abrió el entendimiento fue el de cómo resolver la Ecuación Cuadrática. Al ser una ecuación que a muchos nos enseñan desde la escuela, podemos ver cómo tranformar algo de lo que ya sabemos la solución, a instrucciones que puedan ser entendidas por una computadora.

En la web existe muchísima información sobre algoritmos. Te recomiendo buscar el libro Fundamentos de la Programación de Luis Joyanes Aguilar, es un verdadero clásico.

3. Variables, estructuras de control y funciones

Variables

Las variables son contenedores que nos permiten almacenar un valor, que posteriormente vamos a requerir para hacer una operación. Dependiendo de la información que necesitemos almacenar, esa variable será capaz de guardar por ejemplo números o letras. Al tipo de contenido que almacenan las variables lo conocemos como tipo de dato.

Si queremos hacer un programa que sume dos números, debemos tener tres variables de tipo de dato numérico: las dos primeras para almacenar cada valor a sumar y la tercera, para almacenar el resultado.

Luego tenemos variables que soportan información más compleja, entre ellas podemos encontrar los tipos como arreglos y objetos.

Estructuras de control

Las estructuras de control nos permiten ejecutar o no instrucciones de un programa y además logran que una instrucción se pueda ejecutar varias veces. Las estructuras se dividen en estructuras condicionales y estructuras de repetición.

Funciones

Las funciones son segmentos de código que tienen un conjunto de instrucciones para solucionar un problema. Cuando en un programa se necesita solucionar en distintos puntos el mismo problema, la solución se agrupa en funciones con un nombre, que se puedan usar desde distintos puntos del programa sin tener que repetir las mismas líneas de código en todos lados.

4. Bases de datos

Si bien dentro de un programa podemos almacenar datos dentro de variables, estos datos se almacenan en memoria y son volátiles. Cuando debemos guardar datos en forma permanente usamos bases de datos.

Existen bases de datos de distintos tipos; desde archivos de texto planos, hasta bases de datos relacionales y bases de datos no relacionales, entre otras.

Es necesario aprender el funcionamiento de las bases de datos para poder usar esta herramienta dentro de nuestros programas.

5. Control de versiones

Este punto si bien no es necesario estudiarlo antes de aprender a programar, es una habilidad muy valorada en el mercado laboral actual, que si la aprendemos desde un inicio, nos va a facilitar mucho el desarrollo y sobre todo la integración en los equipos de trabajo.

Los programas de control de versiones nos permiten administrar los cambios que hacemos en el código fuente de nuestros proyectos; ello nos ayuda por ejemplo, a deshacer cambios que hayan generado un error.

Existen diferentes software de control de versiones, siendo de los más conocidos y usados git.

Para concluir...

El verdadero trabajo de un programador no es únicamente conocer uno o varios lenguajes de programación de pies a cabeza, para eso está el internet y los libros; el verdadero trabajo de un programador es usar los lenguajes y tecnologías como herramientas para dar soluciones a los problemas y esto no es posible hacerlo correctamente sin conocer los fundamentos de la programación.

Hay que desarrollar habilidades para la investigación, ya que gran parte del día a día de un programador consiste en exprimir la documentación existente en la web, pero claro, para buscar algo y tener éxito en la búsqueda, hay que saber qué se está buscando.

Otra recomendación es aprender a manejar el estrés, ya que es algo con lo que se convive a diario. Habrán muchas fechas y entregas que cumplir. Es mejor ir desarrollando técnicas para manejar la presión desde el inicio.

Si has llegado hasta acá te deseo mucho éxito en el camino que estás por emprender, si tienes alguna pregunta o aporte, no dudes en comentar. Te estaré leyendo.

En entradas anteriores explicaba cómo Comparar la estructura de dos Bases De Datos con DbWrench. En esta oportunidad voy a mostrar cómo hacerlo para bases de datos PostgreSQL sin necesidad de instalar ninguna herramienta extra.

Versiones más recientes de pgAdmin 4 incorporan una opción para comparar esquemas de bases de datos PostgreSQL. Esta utilidad lleva como nombre Schema Diff.

Inicialmente les comento que la versión que estoy usando de pgAdmin 4 es la 4.21 para Windows:

He creado dos bases de datos diferentes para demostrar la funcionalidad, una llamada movies y otra movies_copy.

La base de datos movies contiene solo dos tablas genres y series:

/* Tabla de Géneros */
CREATE TABLE public.genres
(
    id serial NOT NULL,
    name character varying NOT NULL,
    CONSTRAINT genres_pkey PRIMARY KEY (id)
);

/* Tabla de Series */
CREATE TABLE public.series
(
    id serial NOT NULL,
    name character varying NOT NULL,
    year character(4),
    id_genre integer,
    CONSTRAINT series_pkey PRIMARY KEY (id),
    CONSTRAINT series_genres_fk FOREIGN KEY (id_genre)
        REFERENCES public.genres (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
        NOT VALID
);

Mientras que la base de datos movies_copy contiene tres tablas genres, series (con un cambio en el year) y movies:

/* Tabla de Géneros */
CREATE TABLE public.genres
(
    id serial NOT NULL,
    name character varying NOT NULL,
    CONSTRAINT genres_pkey PRIMARY KEY (id)
);

/* Tabla de Series */
CREATE TABLE public.series
(
    id serial NOT NULL,
    name character varying NOT NULL,
    year character(5),
    id_genre integer,
    CONSTRAINT series_pkey PRIMARY KEY (id),
    CONSTRAINT series_genres_fk FOREIGN KEY (id_genre)
        REFERENCES public.genres (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
        NOT VALID
);

/* Tabla de Películas */
CREATE TABLE public.movies
(
    id integer serial NOT NULL,
    name character varying NOT NULL,
    year character(4),
    id_genre integer,
    CONSTRAINT movies_pkey PRIMARY KEY (id),
    CONSTRAINT movies_genres_fk FOREIGN KEY (id_genre)
        REFERENCES public.genres (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
);

Para hacer la comparación solo tenemos que ir al menú Tools -> Schema Diff:

Luego seleccionar las opciones que correspondan en Select Source y Select Target, y hacer click en Compare. Podremos ir explorando las diferencias encontradas.

1. Schema Diff - Nueva Secuencia de Tabla movies encontrada:
   
2. Schema Diff - Nueva Tabla movies encontrada:
   
3. Schema Diff - Diferencia en estructura de Tabla series:
   



Finalmente podemos generar un Script con los cambios encontrados seleccionando todos los items que queremos que sean incluidos y haciendo click en Generate Script:





El Script generado quedaría de la siguiente manera:

-- This script was generated by a beta version of the Schema Diff utility in pgAdmin 4. 
-- This version does not include dependency resolution, and may require manual changes 
-- to the script to ensure changes are applied in the correct order.
-- Please report an issue for any failure with the reproduction steps. 
BEGIN;
CREATE SEQUENCE public.movies_id_seq
    INCREMENT 1
    START 1
    MINVALUE 1
    MAXVALUE 2147483647
    CACHE 1;

ALTER SEQUENCE public.movies_id_seq
    OWNER TO postgres;

CREATE TABLE public.movies
(
    id integer NOT NULL DEFAULT nextval('movies_id_seq'::regclass),
    name character varying COLLATE pg_catalog."default" NOT NULL,
    year character(4) COLLATE pg_catalog."default",
    id_genre integer,
    CONSTRAINT movies_pkey PRIMARY KEY (id),
    CONSTRAINT movies_genres_fk FOREIGN KEY (id_genre)
        REFERENCES public.genres (id) MATCH SIMPLE
        ON UPDATE NO ACTION
        ON DELETE NO ACTION
)

TABLESPACE pg_default;

ALTER TABLE public.movies
    OWNER to postgres;

-- WARNING:
-- The SQL statement below would normally be used to alter the datatype for the id column, however,
-- the current datatype cannot be cast to the target datatype so this conversion cannot be made automatically.

 -- ALTER TABLE public.series
 --     ALTER COLUMN id TYPE integer;

ALTER TABLE public.series
    ALTER COLUMN year TYPE character(5) COLLATE pg_catalog."default";
CREATE INDEX "None"
    ON public.series(id_genre);

END;




De esta manera logramos comparar la estructura de dos Bases de Datos PostgreSQL únicamente usando la herramienta que nos brinda pgAdmin 4. Espero pueda ser de utilidad y comenta ¿qué te pareció esta funcionalidad? ¿la conocías?.

¿Les ha pasado que les piden unos cambios en el proyecto y luego de que los terminamos y hacemos commits de ellos, deciden que no los quieren? Git nos brinda una manera sencilla de volver nuestro branch a un commit anterior, o en otras palabras, volver en el tiempo.

Existen varias maneras que nos permiten lograr volver a un commit anterior, acá les voy a mostrar como hacerlo con el comando git reset.

Lo primero que debemos hacer es obtener el id (hash) del commit al cual queremos volver y lo podemos hacer de la siguiente forma:

git log --oneline

3ae884e (HEAD -> master) Se le pone corazón al formulario ASAP
1a61b76 Se agregan más opciones al formulario ASAP
0b448af Se agrega formulario ASAP
d4e428e Se agrega formulario de Proveedores
41df9f8 Se agrega formulario de Clientes
1a3a429 Se agrega formulario de Usuarios
2e7e6cd Primer commit

Supongamos en este caso que los cambios que no se quieren son a partir del commit con mensaje Se agrega formulario ASAP, entonces queremos volver al commit d4e428e descrito como Se agrega formulario de Proveedores.

Ejecutaríamos lo siguiente:

git reset --hard d4e428e

Si hacemos nuevamente un:

git log --oneline

d4e428e (HEAD -> master) Se agrega formulario de Proveedores
41df9f8 Se agrega formulario de Clientes
1a3a429 Se agrega formulario de Usuarios
2e7e6cd Primer commit

Podemos ver como ya se han removido todos los commits que seguían a Se agrega formulario de Proveedores. ¡Genial!

Pero como la vida es así de inesperada. Vuelven a decirnos que los cambios si van a requerirse.

¡Nooo! No puede ser... ¿Y ahora? Es el momento de mantener la calma, ya que git nos brinda la posibilidad de volver al futuro.

Lo único que tenemos que hacer es un:

git reflog

d4e428e (HEAD -> master) HEAD@{0}: reset: moving to d4e428e
3ae884e HEAD@{1}: commit: Se le pone corazón al formulario ASAP
1a61b76 HEAD@{2}: commit: Se agregan más opciones al formulario ASAP
0b448af HEAD@{3}: commit: Se agrega formulario ASAP
d4e428e (HEAD -> master) HEAD@{4}: commit: Se agrega formulario de Proveedores
41df9f8 HEAD@{5}: commit: Se agrega formulario de Clientes
1a3a429 HEAD@{6}: commit: Se agrega formulario de Usuarios
2e7e6cd HEAD@{7}: commit (initial): Primer commit

Allí podremos ver el historial completo de cambios de nuestro repositorio local e identificar el hash del commit que tiene el cambio al que queremos ir. En este caso el 3ae884e.

Basta nuevamente con hacer:

git reset --hard 3ae884e

Entonces podemos ver los resultados:

git log --oneline

3ae884e (HEAD -> master) Se le pone corazón al formulario ASAP
1a61b76 Se agregan más opciones al formulario ASAP
0b448af Se agrega formulario ASAP
d4e428e Se agrega formulario de Proveedores
41df9f8 Se agrega formulario de Clientes
1a3a429 Se agrega formulario de Usuarios
2e7e6cd Primer commit

¡Y listo! Ya podemos ver como recuperamos nuestro trabajo.

Gracias Doc. Git, por salvarnos la vida una vez más.

Y ustedes, ¿se han visto alguna vez en esta situación?

Cuando tenemos un teclado en Inglés es molesto no poder insertar los acentos ni letras como la ñ. La verdad nunca busqué una solución al respecto, sin embargo, aprovechando que instalé la nueva versión de Ubuntu 20.04 (Focal Fossa) hice un poco de investigación y me di cuenta de lo fácil que es dar una solución.

Lo que tuve que hacer fue ir al menú Configuración->Región e Idioma y en la opción Fuente de Entrada añadir la opción Inglés (EE.UU. internacional con teclas muertas) como sigue:

Quedando de la siguiente manera:

Ya con esto podemos insertar los acentos sin ningún problema. En el caso de la ñ solo basta con presionar la combinación de teclas shift + ~ y luego la letra n para obtenerla.

Bonus Extra: ¿Cómo insertar el signo de apertura de interrogación ó el de exclamación?

Presionar CTRL + SHIFT + u, y luego escribir bf (para interrogación ¿) o a1 (para exclamación ¡), después presionar ENTER y listo, debe aparecer el símbolo correspondiente. Más info acá.

Instalación de Laravel 7

Para el tutorial, he descargado la versión 7.14.1 de Laravel siguiendo las indicaciones de su documentación oficial.

Para la instalación del Laravel y del paquete que vamos usar requerimos tener instalado Composer.

Requerimientos mínimos para Instalar PHPJasper

• Java JDK 1.6 ó superior.
• PHP 7.2 ó superior.
• Función PHP exec() habilitada.

Instalación de PHPJasper en Laravel 7

Ingresar en el proyecto desde la línea de comandos y ejecutar el siguiente comando:

composer require geekcom/phpjasper

Luego actualizamos para que se descargue:

composer update

¡Y listo! Con eso lo tendrás instalado el paquete.

Uso de PHPJasper en Laravel 7

Si nunca han usado JasperReports pueden ver ésta entrada donde les muestro como crear un reporte en JasperReports desde cero. Les recomiendo Jaspersoft Studio para tal fin. En esta entrada para demostrar el uso de PHPJasper vamos a utilizar los reportes de ejemplo hello_world.jrxml y hello_world_params.jrxml que vienen con el paquete y se encuentran en la ruta vendor/geekcom/phpjasper/examples/.

Inicialmente tienes que añadir la librería donde la vas a usar (para este ejemplo en routes/web.php):

use PHPJasper\PHPJasper; 

La clase PHPJasper nos provee un método para compilar los reportes llamado compile() y se usa de la siguiente manera (no es necesario este paso si lo hace antes desde un programa como Jaspersoft Studio):

Route::get('/compilarReporte', function () {
    $input = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world.jrxml';

    $jasper = new PHPJasper;
    $jasper->compile($input)->execute();

    return response()->json([
        'status' => 'ok',
        'msj' => '¡Reporte compilado!'
    ]);
});

Si todo sale bien al ingresar desde el navegador a la ruta del proyecto /compilarReporte debe recibir un json como respuesta:

{
  "status": "ok",
  "msj": "¡Reporte compilado!"
}

Esto va a crear un nuevo archivo en la ruta vendor/geekcom/phpjasper/examples. Una vez que tengas el archivo .jasper generado puedes ejecutar el reporte desde la ruta /reporte:

Route::get('/reporte', function () {
    $input = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world.jasper';
    $output = base_path() .
    '/vendor/geekcom/phpjasper/examples';
    $options = [
        'format' => ['pdf']
    ];

    $jasper = new PHPJasper;

    $jasper->process(
        $input,
        $output,
        $options
    )->execute();

    $pathToFile = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world.pdf';
    return response()->file($pathToFile);
});

Se debe ver en el navegador el resultado:

Otra de las posibilidades que nos da el paquete es enviar parámetros al reporte, para listar los parámetros que requiere el reporte vamos a usar lo siguiente:

Route::get('/listarParametrosReporte', function () {
    $input = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world_params.jrxml';

    $jasper = new PHPJasper;
    $output = $jasper->listParameters($input)->execute();

    return response()->json([
        'status' => 'ok',
        'parms' => $output
    ]);
});

Si entramos a la ruta /listarParametrosReporte vamos obtener algo como esto:

{
  "status": "ok",
  "parms": [
    "P myString java.lang.String",
    "P myInt    java.lang.Integer",
    "P myDate   java.util.Date",
    "P myImage  java.awt.Image    This is the description of parameter myImage"
  ]
}

Luego de manera similar al primer ejemplo vamos a crear una ruta para compilar el reporte con parámetros:

Route::get('/compilarReporteParametros', function () {
    $input = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world_params.jrxml';

    $jasper = new PHPJasper;
    $jasper->compile($input)->execute();

    return response()->json([
        'status' => 'ok',
        'msj' => '¡Reporte compilado!'
    ]);
});

Si todo sale bien al ingresar desde el navegador a la ruta del proyecto /compilarReporteParametros debe recibir un json como respuesta:

{
  "status": "ok",
  "msj": "¡Reporte compilado!"
}

Para ejecutar el reporte con parámetros necesitamos una imagen en el directorio vendor/geekcom/phpjasper/examples/ en este caso estoy usando el siguiente logo de JasperReports:

Luego defino una ruta para ejecutar el reporte con parámetros como sigue:

Route::get('/reporteParametros', function () {
    $input = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world_params.jasper';
    $output = base_path() .
    '/vendor/geekcom/phpjasper/examples';
    $options = [
        'format' => ['pdf'],
        'params' => [
            'myInt' => 7,
            'myDate' => date('y-m-d'),
            'myImage' => base_path() .
            '/vendor/geekcom/phpjasper/examples/jasperreports_logo.png',
            'myString' => 'Hola Mundo!'
        ]
    ];

    $jasper = new PHPJasper;

    $jasper->process(
        $input,
        $output,
        $options
    )->execute();

    $pathToFile = base_path() .
    '/vendor/geekcom/phpjasper/examples/hello_world_params.pdf';
    return response()->file($pathToFile);
});

El resultado será el como sigue:

Depuración de errores con PHPJasper

Luego de seguir todos los pasos al pie de la letra puede ser que veas el siguiente error:

La clase PHPJasper nos provee una función llamada output() que nos retorna el comando que se esta tratando de ejecutar al generar el reporte. Para poder depurar este comando directamente desde el código lo puedes hacer reemplazando el comando execute con output:

    // Depuración de errores
    dd($jasper->process(
        $input,
        $output,
        $options
    )->output());

De esta manera podrás visualizar el comando que se trata de ejecutar. Solo es cuestión de copiarlo en la consola y ver el verdadero error que te ocurre.

Errores frecuentes con PHPJasper

• Falta de permisos de escritura en la ruta vendor/geekcom/phpjasper/examples/.
• El reporte de ejemplo usa la fuente Arial, es posible que si está en linux veas el siguiente error:

  net.sf.jasperreports.engine.util.JRFontNotFoundException: Font 'Arial' is not available to the JVM. See the Javadoc for more details. at net.sf.jasperreports.engine.util.JRFontUtil.checkAwtFont(JRFontUtil.java:321) at net.sf.jasperreports.engine.util.JRStyledText.getAwtAttributedString(JRStyledText.java:226)

  La solución detallada la encuentras aquí:

  sudo apt-get install ttf-mscorefonts-installer
  sudo cp -r /usr/share/fonts/truetype/msttcorefonts $JAVA_HOME/lib/fonts
      

Espero que sea de utilidad. Cualquier duda o aporte te invito a que la dejes en los comentarios :).

Se han preguntado ¿por qué al hacer un merge entre dos branchs, a veces se añade un nuevo commit que generalmente dice "Merge branch 'nombre_branch'" y en otras ocasiones no lo hace?. Existe una explicación para eso y acá se las voy a dar.

Existen al menos tres posibles resultados cuando hacemos un merge:

• Merge con avance rápido (fast-forward): se presenta cuando por ejemplo creamos un nuevo branch desarrollo a partir del branch master y agregamos cambios en este nuevo branch. Luego cuando vamos a hacer el merge del branch desarrollo a master, si master permanece sin ningún cambio, se producirá un avance rápido. Solo se añadiran los nuevos commits presentes en el branch desarrollo y no se generará ningún commit adicional.


• Merge de tres vías (3-way): siguiendo el ejemplo de crear un branch desarrollo a partir del branch master. Imaginemos que se existen nuevos commits en master al momento de querer hacer el merge del branch desarrollo, git se encarga de hacer la unión y se va a ver reflejado en un nuevo commit que por defecto tiene como mensaje similar a "Merge branch 'desarrollo'".


• Merge con conflictos: cuando se presenta un merge con conflictos por resolver, siempre se crea un nuevo commit que representa la solución de los conflictos.

Si quieres ampliar la información y verla de manera gráfica, puedes visitar el siguiente enlace.

Desde que aprendí el truco para mostrar el branch actual de git en el terminal de Linux, siempre lo uso cuando configuro cada nuevo entorno.

Es súper fácil, solo editar el siguiente archivo:

nano ~/.bashrc

Y copiar al final de todo lo siguiente:

mostrar_git_branch() {
     git branch 2> /dev/null | sed -e '/^[^*]/d' -e 's/* \(.*\)/ (\1)/'
}
export PS1="\u@\h \[\033[32m\]\w\[\033[36m\]\$(mostrar_git_branch)\[\033[00m\] $ "

Reiniciar la terminal y listo. Debe verse de la siguiente forma:

~/git_hacks (master) $

Podemos cambiar el color del branch sustituyendo el código [36m\], por el código correspondiente al color:

• Negro [30m\]
• Rojo [31m\]
• Verde [32m\]
• Amarillo [33m\]
• Azul [34m\]
• Magenta [35m\]
• Cyan [36m\]
• Blanco [37m\]

Referencias:

• https://sujipthapa.co/blog/git-pro-tip-show-your-branch-on-linux-ubuntu-terminal
• http://dvtprueba.blogspot.com/2014/10/linux-y-git-mostrar-el-branch-actual-en.html