Jorge Jara

[ES] Mi propia calculadora IPC

Thu, 22 Jul 2021 02:05:00 GMT

Estaba en medio de una de mis típicas crisis de aburrimiento tratando de buscar una idea para una app en React (buscar ideas factibles nunca ha sido mi fuerte) cuando, de repente, me acordé de la calculadora de variación del IPC que ofrece el INE (Instituto Nacional de Estadísticas, el ente chileno a cargo de cosas como el censo y estadísticas vitales) para determinar el poder adquisitivo del peso chileno (CLP) a lo largo del tiempo. La página cumple su propósito, sin lugar a dudas, pero me pregunté si podría hacer una propia que cumpla el mismo propósito, usando tecnologías más recientes y que se vea ligeramente mejor. Como me pareció una excelente idea para una app de la que me sentiría lo suficientemente orgulloso como para no tener oculta en una carpeta de mi PC, me dispuse a crear un proyecto Next.js y me puse manos a la obra.

La calculadora del INE, hecha con las mejores tecnologías que el año 2008 puede ofrecer.

Como pueden ver, la página de la que me estoy inspirando cumple su propósito, pero encuentro que podría mejorarse. Por ejemplo, la parte donde se especifican los intervalos de fechas y el monto a convertir es muy pequeña comparada al contenedor donde salen los resultados. Además, el valor ajustado, que es el resultado que cualquier persona que considere que la pregunta “¿cuánto costaría el pasaje de micro en mayo de 1987 en plata de hoy?” es digna de hacerse busca, está “relegado” a un texto más pequeño que el porcentaje de variación que, aunque importante, considero que podría dejarse más en un segundo lugar.

Volviendo a mi app, me puse a trabajar y, una vez tuve configurado el proyecto Next.js con TypeScript y Tailwind CSS, empecé a ver cómo podría rescatar la información sobre la variación del IPC (Índice de Precios al Consumidor). Partí revisando la página del INE en busca de alguna base de datos pública o algo, pero solo encontré las estadísticas desagregadas por tipo de bien o servicio en lugar del porcentaje de variación mensual y, ya que la estadística no es lo mío, decidí mejor probar con la misma API que usa la calculadora. Como quería evitar dentro de lo posible enviar repetidas consultas a su endpoint estando la aplicación en producción, pensé en descargar una sola vez toda la información que pudiera, ponerla en algún tipo de base de datos e irla actualizando cada mes.

Para tener una tabla propia con la variación mensual del IPC, creé un script en Python que llamara de forma repetida a la API del INE, consultando por la variación de $ 1000 millones (para obtener una buena cantidad de decimales) mes a mes desde marzo de 1928. Habría usado un número más grande, pero la plataforma no me dejaba usar más de 10 dígitos (ugh). Luego, extraje la información en XML (doble ugh) y mandé todo a un archivo CSV, el cual copié en una planilla de Google Sheets. Decidí usar esto en lugar de desplegar un servidor base de datos real (profe Varas, perdóneme si lee esto xd) porque no necesitaba algo muy complejo para esta aplicación y porque iba a aprovechar la capacidad de Next.js de generar sitios estáticos en tiempo de compilación para insertar la tabla de IPC en la misma página, actualizándola sólo cuando se añada una nueva entrada cada mes. De esa manera puedo ofrecer resultados a medida que el usuario tipea sin usar una API externa.

Con respecto al diseño, ocupé toda mi energía creativa en diseñar esta obra de arte:

Acepto ofertas como diseñador gráfico. No se peleen por mí.

No es la aplicación más bonita del mundo, pero el formulario mismo es más grande y muestra el valor calculado en mayor tamaño, además de que es responsiva y compatible como PWA.

Con respecto al uso, es simple de usar: definimos un intervalo de tiempo, un monto en el cuadro de texto y, a medida que escribimos, vamos obteniendo el resultado. Hice repetidas pruebas con la calculadora del INE para asegurarme de que los valores coinciden y lo logra perfectamente, aunque con cifras muy grandes los valores empiezan a diferir (no ocupé todos los decimales que me retornaba la API por temor a que hubiera artefactos producto de ser números de coma flotante).

Si les interesa echarle una mirada, pueden visitarla haciendo clic aquí e instalarla como PWA si gustan. Además, el proyecto con el código que usé para la app lo pueden encontrar acá. Si tienen alguna duda o problema, no duden en contactarme o reportar un bug o pull request en el repositorio. ¡Hasta la próxima!

[ES] Mi primer paquete en NPM

Tue, 27 Apr 2021 14:53:00 GMT

Hace unos días, después de pasar un buen rato programando y corrigiendo algunos errores que cometí en el camino, ¡finalmente publiqué mi primer paquete NPM!

Mi pequeña creación se llama react-rut-formatter y básicamente implementa un hook que se encarga de darle formato a un número de RUT (Rol Único Tributario) o RUN (Rol Único Nacional), que son utilizados en Chile como números de identidad para fines personales o tributarios. Todo con el encanto de TypeScript incorporado, pues considero que hace mucho más placentero y predecible trabajar con JavaScript.

Por lo general un número de RUT se escribe de la forma XX.XXX.XXX-X, donde el último carácter es un dígito de control (llamado acá dígito verificador), que se calcula a partir de los demás números que lo anteceden. No es una operación muy compleja calcular aquel dígito ni darle formato (con separadores de miles y todo), pero encuentro que nunca estaría de más tener una librería a mano para que, a medida que un usuario escribe uno en un formulario, el número vaya siendo formateado automáticamente, algo muy habitual en ciertas aplicaciones web chilenas (que necesitan un RUT o RUN para identificar a sus usuarios).

Demostración de `react-rut-formatter`

El repositorio con el código está disponible en GitHub y debería estar utilizable. Sin embargo, acepto cualquier comentario o problema en la sección de Issues, pues es la primera vez que subo código que espero que más gente pueda utilizar y la experiencia manejando bugs nunca está de más. También está publicado en NPM y puede ser instalado utilizando su gestor de paquetes de preferencia (ya sea yarn o npm).

Pueden encontrar una demostración del paquete aquí, por si les interesa verlo funcionando.

[ES] Sintáxis básica de C++ (parte 3)

Thu, 08 Apr 2021 14:53:00 GMT

Hola! En esta tercera parte de mi serie sobre sintaxis de C++, hablaré de dos detalles que son cruciales en mi opinión para conseguir programas eficientes que trabajen de la manera más óptima posible con las variables que utilizan en su código: cuándo utilizar la memoria dinámica (heap) y cómo configurar los parámetros de una función para evitar copias innecesarias de recursos y evitar la sobreescritura de argumentos que, en principio, son sólo de entrada.

Variables y memoria

En esta sección vamos a ver un tema que creo que es importante y es dejado a un lado a mi parecer: ¿en qué parte de la memoria deberíamos guardar las variables con las que trabajamos? ¿En la pila (stack) o en el montículo (heap, memoria dinámica)?

Tanto stack como heap funcionan de forma diferente al momento de asignar o liberar memoria. En el caso del stack, el sistema operativo asigna una cantidad de memoria a cada proceso para que en él guarde la pila de llamadas (call stack) y las variables locales que cada función pudiera tener. No es una cantidad excesivamente grande (unos cuantos megabytes), pero es suficiente para que un programa pueda alcanzar una buena profundidad de llamadas sin colapsar. El heap es una historia diferente. En este caso podemos pensar literalmente en un montículo lleno de bytes disponibles que se van asignando a los diferentes procesos según lo requieran. Cuando un programa solicita memoria al heap (usando internamente la función malloc en sistemas UNIX), este recibe a cambio un puntero ubicando en algún sector de la memoria los bytes que solicitamos. Cuando ya se hizo uso de la memoria, esta se devuelve al montículo (función free) para que otros procesos puedan utilizarla. Tanto stack como heap son memoria RAM al fin y al cabo, ¿verdad? Entonces, ¿debiera importarme en cuál de ellas guardo mi información? Absolutamente.

Aunque en la práctica ambas van a ser igual de rápidas y eficientes, para el programador debe ser importante hacer un buen uso de estas, especialmente considerando que el stack tiene una capacidad limitada (en mi sistema son 8 MiB, para que se hagan una idea) y, al menos en C++, el heap requiere trabajar con punteros, algo que hasta para el programador más avezado podría significar varios dolores de cabeza.

Una regla que deberían considerar cuando programen es usar punteros la menor cantidad de veces posible, porque aunque sepan al revés y al derecho cómo usarlos, nunca va a faltar la ocasión en que usen . en lugar de ->, terminen con errores de compilación incomprensibles y vean que el programa se la pasa tirando fallos de segmentación porque también les faltó desreferenciar su puntero a alguna estructura y el programa empezó a volverse loco. Lo ideal sería trabajar con punteros sólo cuando tengan que implementar estructuras de datos (como listas, vectores o mapas) y el resto de las ocasiones usar smart pointers (un tipo de objeto que implementa una interfaz más ordenada y menos proclive a errores para trabajar con punteros a memoria). Más adelante podremos ver cómo se utilizan y cuándo.

Entonces, yendo al grano, ¿cuándo deberíamos usar el heap o el stack? En el caso del stack, podemos utilizarlo con calma cuando trabajemos con arreglos pequeños de tipos pequeños (un arreglo de enteros, de caracteres), estructuras que no tengan un gran tamaño o clases tambien pequeñas:

int numeros[50];
char nombre[64];

struct {
    int num;
    char tipo[8];
} peque; // Esta notación permite definir una estructura al
         // mismo tiempo que creamos una variable de ese tipo

double x = 2.0; // Variables comunes y corrientes como esta
                // ya se almacenan en el stack

// La clase que creamos anteriormente
Persona nic("Nicholas Cage", 57);

// INNECESARIO
// Solo ocupa 28 bytes (x86 modernos)
Persona *keanu = new Persona("Keanu Reeves", 56);

Una excepción a esto son tipos como std::string o std::vector, los cuales solicitan ellos mismos memoria al heap y cuyo tamaño como tal solo corresponde a punteros y números que almacenan información sobre los datos que almacenan:

std::string saludo = "¡Hola, mundo!";
std::vector primos{2, 3, 5, 7, 11, 13};

// INNECESARIO
// Tanto ctor como dtor de std::list
// ya contemplan solicitar memoria
// del heap
std::list<int> *lista = new std::list<int>();

Luego, con respecto al heap, donde brilla es utilizándolo para almacenar grandes cantidades de información, ya sea un gran número de estructuras pequeñas, un número reducido de estructuras enormes o cualquier otra monstruosidad que su programa necesite:

// Definitivamente así no es cómo un juego guarda una textura,
// pero en memoria esto va a ocupar ~196 KiB, así que de
// guardarse en el stack lo vamos a llenar bien rápido.
// Por tanto, nos sirve para el ejemplo
class Textura {
private:
    char r[256][256];
    char g[256][256];
    char b[256][256];
public:
    // ...
};

// Esto va a ocupar ~4 MiB de memoria, así que, de guardarse
// en el stack, este no podría aguantar muchas variables
// como esta
Textura *mapa_texs = new Textura[64];

double *coefs = new double[1024]; // 8 KiB de memoria

Textura *jugador = new Textura(...);

// ...

// No se olviden de liberar la memoria que usen, especialmente
// si el programa va a seguir corriendo después de hacerlo!
delete[] mapa_texs;
delete[] coefs;
delete jugador;

Insisto en que manejen bien estas reglas e idealmente investiguen también por cuenta propia cómo funciona lo que explico, porque los malos hábitos nunca mueren y, cuando menos se lo esperen, el proyecto en el que han trabajado por meses empezó a dejar de funcionar porque o llenaron el stack de su programa o el heap ya no tiene espacio para asignar 500 MiB porque ya asignaron chorrocientos elementos de 10 bytes cada uno (creo que esto último no es algo plausible, pero más vale prevenir que lamentar).

Uso adecuado de parámetros

Tengo que confesarles algo, buena parte de los ejemplos de código que he entregado no son idóneos realmente. Quiero decir que funcionan como tal, pero he omitido deliberadamente algunos detalles con respecto a algunas variables para motivos de simplicidad. Aquí voy a enmendar mi “error” y les explicaré cómo esperar parámetros adecuadamente en una función y cómo utilizar los for basados en rango de forma adecuada desde un punto de vista de memoria, ¡todo en un Solo Cómodo Paquete™! ¡Llame ahora, mientras nuestras operadoras no estén ocupadas!

Parámetros y argumentos

Antes de empezar, les cuento una cosita. No es una regla escrita en piedra, pero por lo general se le denomina parámetros a la lista de variables que una función lleva en su huella (o signature) al momento de definirla, mientras que argumentos se llaman los valores que se le entregan a una función cuando se invoca.

void func(int a, char b); // Aquí se llaman parámetros

// ...

func(123, 'a'); // Y aquí argumentos

No es una convención que la totalidad de los programadores siga, pero nunca está de más saberlo.

¿Cómo definimos los parámetros, entonces?

Muy simple. Esta tabla que tienen a continuación explica bien cómo definir los tipos de cada variable según las circunstancias en las que los usen:

Cortesía de Modernes C++

De todos modos, explicaré caso a caso cuándo se usa cuál.

Parámetros de entrada (in)

Este es el caso más usual que se van a encontrar. Ocurre cuando entregan un valor para que la función lo consuma sin preocuparse de retornarlo a través del mismo:

void imprimir_texto(const std::string& str) {
    std::cout << str;
}

imprimir_texto("Hola\n");

Acá podemos ver dos cosas: primero, que estamos pasando str como una referencia (&), lo que quiere decir que no estamos duplicando la variable que entregamos al invocar imprimir_texto (estamos trabajando con el mismo literal "Hola\n" sin hacer una copia de él). Además, al definirlo como const, nos aseguramos de que no vamos a editar innecesariamente a str, pues no es el objeto de esta función. Usar const o no no afecta su código, sino que simplemente le dice al compilador que esté atento a que la variable no puede reasignarse.

Este comportamiento de no duplicación no ocurre si omitimos el &, lo que puede ser una muy mala idea si estamos trabajando con variables muy grandes;

std::string texto_muy_largo;

// ...

// Imaginemos que texto_muy_largo contiene un archivo
// de texto de 5 MiB y queremos imprimirlo en pantalla.

void imprimir_texto_mal(const std::string str) {
    std::cout << str;
}

// En este caso, vamos a trabajar sobre la variable
// misma sin duplicarla, lo que nos ahorra tiempo
// y memoria
imprimir_texto(texto_muy_largo);

// En cambio, acá estamos haciendo lo mismo, pero
// de forma más ineficiente, pues estamos duplicando
// el contenido de texto_muy_largo en otra variable
// (el parámetro que recibe la función), lo que
// implica desperdiciar memoria y tiempo copiando
// los contenidos del string
imprimir_texto_mal(texto_muy_largo);

Todo esto que expliqué aplica únicamente para tipos que no son baratos de copiar o que simplemente no se pueden copiar (como std::unique_ptr, que veremos prontamente). Tipos primitivos como int o boolean son baratísimos de copiar, por lo que la optimización de usar & cuando son parámetros de entrada es innecesaria:

// Bien: Barato porque es una referencia a constante
void f1(const std::string& str);

// Mal: Puede ser muy costoso si el string es muy
// grande
void f2(std::string s);

// OK: Imbatible. Podría hasta ser copiado en un
// registro de CPU
void f3(int x);

// Innecesario: Implica una sobrecarga extra para
// convertir la referencia en un valor
void f4(const int& x);

Parámetros de salida (out)

Con parámetro de salida me refiero a aquel que, en vez de ser usado para que la función reciba datos, es usado para retornar información al programador. Esto incluye también al valor de retorno de la función en cierto modo.

La mayoría de las veces va a ser posible retornar información como parte del retorno de una función sin mayor problema:

// Todo esto está bien
int f5(...);            // Se entrega en el stack
std::string f6(...);    // Ídem. El contenido del string se
                        // mantiene en el heap.

En estos casos corren ciertas optimizaciones que permiten que retornar objetos como un std::string no implique un mayor costo para el programa, así que si tienen que retornar uno como en f6, pueden hacerlo como si fuera un tipo primitivo más.

Sin embargo, existe una excepción que, aunque no es algo muy frecuente, vale tener en consideración. Si trabajan con estructuras grandes como esta:

struct Packet {
    char header[128];
    char payload[4096];
}

pueden encontrarse con problemas si definen una función como Packet gen_paquete(), pues retornar más de 4 KiB en el stack puede ser ineficiente, especialmente si se tratara de un arreglo de Packet.

Entonces, ¿qué hacemos para retornar estructuras enormes como esta? Aquí vamos a hacer uso de las referencias no constantes:

void gen_paquete(Packet& packet) {
    // ...
}

Acá, en vez de retornar el paquete de la forma tradicional, lo que hacemos es definir uno vacío y que sea la función la que lo rellene, esto gracias a que estamos trabajando con una copia por referencia. Así, esta función puede ejecutarse de este modo;

Packet p; // Sus arreglos van a estar no inicializados

gen_paquete(p); // Acá los inicializamos

// Ya en este punto la variable p contiene valores válidos

Ya con esto tenemos definidos la mayoría de los casos en que van a encontrarse con parámetros en una función. Existen otros más, los que pueden ver si abren el enlace de donde conseguí la tabla, pero considero que estos son los esenciales y los que importa saber si aún no conocen conceptos más avanzados del lenguaje.

Adenda: `for` basados en rango

Considerando lo que hemos visto, si están trabajando con bucles for basados en rango, es posible también usar referencias en estas, especialmente si piensan editar los valores que reciben en cada iteración, como pueden ver en este ejemplo:

std::vector<int> nums{1, 2, 3, 4, 5};
for (int& num : nums) {
    num *= 2;
}

// Saliendo del bucle, veremos que nums
// ahora contiene los números {2, 4,
// 6, 8, 10};

Con valores chicos como int, no debería ser necesario usar referencias si no van a modificarlos, pero, sin embargo, recomiendo encarecidamente usar const para evitar posibles bugs si terminan editando el valor involuntariamente:

for (const int num : nums) {
    nun *= 2; // En este caso el compilador
              // saltará con un error
}

Con esto terminamos esta entrega de mi ahora ya serie sobre sintaxis básica de C++. Espero verlos en la próxima entrega. ¡Hasta pronto!

[ES] Sintáxis básica de C++ (parte 2)

Thu, 18 Mar 2021 00:34:00 GMT

En esta segunda parte de esta serie veremos uno de los principales elementos que distinguen a C++ de su antecesor: las clases. Además, haremos un pequeño paseo por algunos contenedores básicos que ofrece la STL.

Clases

Las clases son la piedra angular de la programación orientada a objetos. Básicamente son armazones con los cuales uno crea objetos que pueden contener datos y que, además, pueden operar con esos datos. Una clase, por lo general, va a estar compuesta de dos archivos: un archivo de cabecera (generalmente usando la extensión .h o .hpp), que define su estructura, y un archivo fuente (.cpp, .cxx, .cc, entre otras; queda a gusto del programador cuál usar), que implementa el código definido por la estructura.

El archivo de cabecera de una clase puede verse de la siguiente forma:

// persona.h

// Estas líneas (llamadas directrices de preprocesador,
// que, en este caso, forman un "include guard") le
// indican al compilador que lea este archivo sólo
// una vez, en caso de que sea utilizado en más de un sitio.
// Todo archivo .h debiera utilizarlas
#ifndef PERSONA_H
#define PERSONA_H

// Una alternativa no estándar pero soportada por la
// mayoría de los compiladores es #pragma once. Si usaran
// esta forma, omitan el include guard (las líneas que parten
// con #ifndef y #define y la línea #endif al final del
// documento). Solo deberían usar una de estas a la vez.
#pragma once

#include <string>

// Una clase puede tener miembros:
//   - públicos (accesibles por cualquiera)
//   - privados (accesibles sólo por la clase misma)
//   - protegidos (accesibles sólo por la clase
//     misma y sus subclases)

class Persona {
// Estos no podrán ser accedidos desde fuera de la clase.
// Si tuviéramos una instancia de Persona llamada p,
// escribir p.nombre va a generar un error de compilación
private:
    // Tanto nombre como edad se denominan atributos
    // (o campos). Funcionan como variables, las cuales
    // serán únicas para cada instancia de Persona (es
    // decir, cada persona tendrá su propio nombre y edad)
    std::string nombre;
    unsigned edad;

// En cambio, estos pueden utilizarse desde fuera y funcionan
// como la cara visible de la clase
public:
    // Este es el constructor (puede haber más de uno), donde
    // se inicializa cada instancia de la clase, se definen
    // sus valores iniciales, entre otras cosas. Un
    // constructor no especifica un tipo de retorno.
    Persona(std::string nombre, unsigned edad);

    // Estas funciones se denominan métodos. Los métodos
    // pueden acceder a los atributos de cada instancia y
    // trabajar con estos.
    std::string get_nombre();
    unsigned get_edad();
};

#endif // PERSONA_H      Omitir si usan #pragma once

// clase.cpp

// En este archivo vamos a implementar tanto el
// constructor como los dos métodos que están definidos
// en el archivo de cabecera.

#include "persona.h"

// Para implementar los métodos de una clase,
// anteponemos al nombre de cada uno el de la clase,
// seguido de ::
Persona::Persona(std::string nombre, unsigned edad)
  : nombre(nombre), edad(edad) {
    // Esta de arriba es una notación especial que nos
    // permite asignar directamente el valor de cada
    // argumento con un atributo de la clase (en este
    // caso, el atributo nombre recibe el valor del
    // parámetro del mismo nombre; lo mismo con edad)

    // Podemos hacer esto en lugar de la forma
    // anterior si gustan
    // this->nombre = nombre;
    // this->edad = edad;

    // El puntero this nos permite acceder a todos los
    // atributos de la instancia actual de la clase.
    // La usamos en este caso para evitar ambigüedades
    // (ya que atributo y parámetro se llaman igual)
}

std::string Persona::get_nombre() {
    // Como en este caso no hay otro elemento llamado
    // nombre en la función, podemos prescindir del
    // this-> con seguridad
    return nombre;
}

unsigned Persona::get_edad() {
    return edad;
}

Luego, para utilizar la clase en nuestro código, podemos hacer lo siguiendo, sin olvidar incluir el archivo .cpp entre los que el compilador va a recibir:

// main.cpp

// Los archivos de cabecera que son parte del proyecto
// debieran ser incluidos usando comillas dobles (""),
// mientras que las librerías de sistema con <>
#include <iostream>
#include "persona.h"

int main() {
    // Así creamos una instancia cuyo atributo
    // nombre contendrá el string "Juan López"
    // y edad el número 40. Noten que los argumentos
    // dados coinciden con los parámetros definidos
    // en persona.cpp y persona.h
    Persona p("Juan López", 40);

    std::cout << p.get_nombre() << " tiene "
              << p.get_edad() << " años.\n";

    // Retornamos 0 para indicar que el programa
    // se ejecutó exitosamente
    return 0;
}

Podríamos compilar el programa con esta llamada a g++:

g++ -o prueba_persona main.cpp persona.cpp

Si desean mantener los archivos de cabecera y fuente separados, pueden hacer uso de esta estructura de archivos:

prueba_persona/
 |-- src/                 Archivos fuente
 |    |- main.cpp
 |    \- persona.cpp
 \-- include/             Archivos de cabecera
      \- persona.h

Para compilar, pueden usar este comando (asegurándose de estar en la carpeta prueba_persona):

g++ -o prueba_persona src/main.cpp src/persona.cpp -I include/

El argumento -I <carpeta> le indica al compilador dónde tiene que buscar los archivos .h que hemos creado, ya que no están en la misma carpeta que los .cpp.

Constructores y destructores

Antes de continuar, me quiero detener un momento para explicar un poco más sobre los contenedores y destructores, también llamados ctor(s) y dtor(s) (a partir de los términos constructor(s) y destructor(s) en inglés). Estos dos son métodos especiales dentro de una clase y son llamados al momento de crear una instancia de esta o cuando el objeto se sale de scope o se invoca a delete, respectivamente (veremos estos últimos dos casos en detalle después).

Constructores

Como mencionaba, los constructores se ejecutan al momento de crear una instancia de clase. Por lo general se encargan de inicializar los atributos de la nueva instancia y, por tanto, puede recibir argumentos de parte del programador. También es posible definir más de un constructor en caso de ser necesario.

Cabe también agregar que si no definimos un constructor en nuestra clase, el compilador nos proveerá uno trivial. Además, los atributos que puedan construirse por defecto (como los contenedores y tipos de la STL) lo harán automáticamente, añadamos o no un constructor.

class Clase {
private:
    std::string nombre;
    unsigned edad;
public:
    Clase();
    Clase(std::string nombre, unsigned edad);
};

Clase::Clase() : nombre(""), edad(0) {
    // ...
}

Clase::Clase(std::string nombre, unsigned edad)
  : nombre(nombre), edad(edad) {
    // ...
}

En este ejemplo, podemos ver que Clase(std::string, unsigned) asignará el nombre y edad que le entregamos a los atributos del mismo nombre, lo que es usual. Con respecto a Clase(), lo que ocurrirrá es que tanto nombre como edad se definan como "" y 0, respectivamente. Ambas definiciones son válidas y no producen conflictos entre sí, ya que los parámetros que esperan son diferentes (ninguno contra un std::string y un unsigned).

Si, por ejemplo, Clase también contuviera un puntero bruto a memoria, podríamos inicializarlo haciendo uso de malloc o free dentro del constructor, sin olvidarse de liberar los recursos solicitados en el destructor, que es lo que veremos a continuación.

Destructores

Cuando nuestra instancia se sale de scope o ejecutamos delete, el programa llamará al destructor de nuestra clase, el cual se encargará de liberar graciosamente cualquier asignación de memoria que hayamos hecho, además de “saldar cuentas” en nuestra función si es necesario:

class ClaseConDtor {
private:
    std::string str;
public:
    ClaseConDtor();
    ~ClaseConDtor(); // Este es nuestro destructor.
                     // Un destructor nunca recibe
                     // argumentos
}

if (...) {
    ClaseConDtor a(); // Creamos una instancia

    // ...
}
// Al momento de abandonar el if, el destructor
// es llamado automáticamente. El atributo str
// también invoca al suyo y libera la memoria
// que utilizaba el string

class ClaseConDtorMem {
private:
    // ...
public:
    ClaseConDtorMem();
    ~ClaseConDtorMem();
}

// Creamos una instancia en el heap
// (traten de usar punteros lo menos posible, insisto)
ClaseConDtorMem *c = new ClaseConDtorMem();

// ...

delete c; // Aquí invocamos al destructor de nuestra
          // clase. Una vez hecho, la memoria que
          // solicitó es devuelta al SO

Si su clase no utiliza punteros en bruto, por lo general no va a ser necesario definir un destructor, pues el que entrega el compilador por defecto va a servir en la mayoría de los casos. Como veíamos anteriormente, cualquier instancia de clase que ya tenga definido su propio destructor (como el string de ClaseConDtor) lo va a llamar al momento de invocar el nuestro, lo que nos permite despreocuparnos de ver si el destructor de los atributos fue llamado, pues se hará automáticamente.

Contenedores

Ya que casi todo programa necesita almacenar datos de una forma u otra, se vuelve necesario trabajar con estructuras que los almacenen y nos permitan operar con ellos. Para aplicaciones simples podemos recurrir al clásico arreglo (ya sea de tamaño fijo o variable), pero si nuestros datos ganan complejidad o necesitamos ciertas garantías de tiempo (como adición o lectura en tiempo constante), vamos a tener que utilizar otro tipo de enfoque. El tema es que muchas de las veces estamos reinventando la rueda y no necesitamos realmente crear nuestras propias clases cuando podemos utilizar código hecho por expertos en el tema (a menos que nos estén enseñando cómo funcionan estas estructuras, claro está). Es por esto que les mostraré algunas de estas estructuras que vienen “de fábrica” en cualquier implementación de la librería estándar de C++.

Arreglos dinámicos (`std::vector`)

Esta es uno de los contenedores más simples de usar y el que más se van a encontrar. std::vector implementa un arreglo de tamaño variable que se encarga de forma automática de agrandar la estructura subyacente que almacena la información:

// Este arreglo es de tamaño fijo. Podemos
// alterar los números que ya contiene, pero
// no podemos agregarle ni quitarle celdas.
int nums[] = {0, 1, 1, 2, 3, 5, 8};

nums[8] = 13; // A menos que quieran que su programa
              // falle o no compile, no hagan esto.

#include <iostream>

#include <vector> // Tenemos que incluir esta librería
                  // para usar vectores

#include "persona.h"

// Como nums2 es un vector, podemos alterar los números
// que contiene, agregar y eliminar a libertad.
std::vector<int> nums2{0, 1, 1, 2, 3, 5, 8};

nums2.push_back(13); // Así agregamos un número al final
int trece = nums2.pop_back(); // Y así lo eliminamos

// Así podemos obtener el tamaño del vector
std::cout << nums2.size() << std::endl;

// Así inicializamos un vector vacío
std::vector<Persona> gente;

// Y así podemos construir "in situ" una instancia,
// si es que el tipo es construible. Tan solo tenemos
// que pasar los mismos parámetros que de costumbre.
gente.emplace_back("Alan Turing", 41);

// Eso es equivalente a esto:
Persona alan("Alan Turing", 41);
gente.push_back(alan);

// Si queremos limpiar el vector, llamamos a clear()
gente.clear();

// Para comprobar que lo limpiamos, podemos usar
// el método empty() o chequear que size() == 0
if (gente.empty()) {
    std::cout << "Vacío" << std::endl;
}

// if (gente.size() == 0) {
//    std::cout << "Vacío" << std::endl;
// }

Listas enlazadas (`std::list`)

A diferencia de los vectores, que almacenan su información en un trozo contiguo de memoria que se va moviendo a medida que aumenta el número de elementos que debe almacenar, las listas enlazadas pueden perfectamente estar desperdigadas en la RAM y siguen siendo totalmente accesibles y modificables.

Una lista enlazada se compone de nodos, que contienen la información que queremos guardar, y punteros que apuntan al siguiente elemento en la cadena (lista simplemente enlazada) o, incluso, al elemento anterior y siguiente (lista doblemente enlazada):

Cortesía de Studytonight

La ventaja de las listas doblemente enlazadas es que permiten la inserción y eliminación de elementos en tiempo constante tanto al inicio y final de ella.

#include <list>

// Una lista doblemente enlazada
std::list<int> lista{1, 2, 3, 4, 5};

lista.push_back(6);

// Ahora la lista queda
// 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6

lista.push_front(7);

// Ahora la lista queda
// 7 <-> 1 <-> 2 <-> 3 <-> 4 <-> 5 <-> 6

lista.pop_back();
lista.pop_back();
lista.pop_front();

// Finalmente:
// 1 <-> 2 <-> 3 <-> 4

Como es posible recorrer una lista doblemente enlazada de atrás hacia adelante, podemos iterar un std::list en reversa, algo que veremos con detalle en otra ocasión:

std::list<int> fibonacci{0, 1, 1, 2, 3, 5, 8, 13};

// Iteración regular (de inicio a fin)
for (int n : fibonacci) {
    std::cout << n << std::endl;
}

// Iteración en reversa
auto it = fibonacci.rbegin();
auto end = fibonacci.rend();
for (; it != end; ++it) {
    std::cout << n << std::endl;
}

// El tipo auto nos permite omitir el tipo de una variable
// si es muy largo y deja su determinación a cargo del
// compilador

// La anterior sintaxis no es la más cómoda (de hecho,
// es una de las razones por las que puse el iterador
// inicial y de fin en líneas aparte para mejorarlo
// un poco), pero desde C++20 en adelante existe una
// forma mucho más simple que podemos usar, gracias
// a la nueva librería ranges

#include <ranges>

for (int n : fibonacci | std::views::reverse) {
    std::cout << n << std::endl;
}

// El operador tubería (|) le entrega la lista a
// std::views::reverse, el cual invierte los iteradores
// y permite recorrerlo en reversa con menos código

Listas simplemente enlazadas

Si queremos trabajar con listas simplemente enlazadas (tanto porque no nos interesa la iteración en reversa o porque queremos ahorrar espacio) basta con usar la variante std::forward_list, que funciona de forma idéntica a std::list:

#include <forward_list>

std::forward_list<int> simple{1, 2, 3};

// Iteración regular (de inicio a fin)
for (int n : simple) {
    std::cout << n << std::endl;
}

// ESTO NO VA A FUNCIONAR
auto it = simple.rbegin();
auto end = simple.rend();
for (; it != end; ++it) {
    std::cout << n << std::endl;
}

Conclusión

Esperando que les haya servido este artículo, en la próxima iteración veremos las dos principales formas de almacenar variables en memoria (heap y stack), además de cómo las funciones debieran recibir parámetros si queremos lograr un manejo eficiente de la memoria. ¡Nos vemos en la próxima!

[ES] Sintáxis básica de C++ (parte 1)

Tue, 16 Mar 2021 19:00:00 GMT

Hola, con este artículo doy inicio a una serie de posts explicando la sintaxis básica y expresiones usadas en las versiones modernas de C++ (C++11 en adelante). Hay mucho material dando vueltas por internet que explica lo mismo que quiero hacer, pero que suele estar enfocado en versiones anteriores de la norma y, hoy por hoy, están bastante desactualizados, considerando que en los últimos 10 años se han añadido bastantes características que han mejorado el uso del lenguaje considerablemente y lo han vuelto una herramienta aún más poderosa si se usa de forma apropiada.

En este primer artículo explicaré lo básico sobre estructuras de control, variables, tipos de variables y bibliotecas y la estructura de un programa sencillo. No explicaré todo desde cero porque asumo que quien lea esto entenderá lo básico sobre programación. No es necesariamente cosas que fueron añadidas en versiones recientes del lenguaje, pero esto nos permitirá sentar una base para lo que venga a futuro.

Variables

Una variable se podría definir como un contenedor o recipiente que alberga algún tipo de dato en memoria, como puede ser un entero, una cadena de caracteres, un arreglo de números decimales, entre muchos otros.

// Una variable se define de la forma
// <tipo> <nombre> [= <valor inicial>];

// Un número entero entre -2^31 y (2^31)-1
// en arquitecturas de PC modernas
int nice = 69;

// Un número sin signo entre 0 y (2^32)-1
unsigned poblacion = 18730000;

// Un número entre -128 y 127 (usualmente
// utilizado para caracteres ASCII básicos)
char a_mayus = 'A';

// Un número flotante de precisión simple (~7 decimales)
float un_medio = 0.5;

// Flotante de precisión doble (~15 decimales)
double pi = 3.141592653589793

// Un valor booleano (verdadero/falso)
bool es_verdad = false;

// Una cadena de caracteres terminada en 0 y
// de tamaño fijo (el 0 es implícito; lo
// añade el ompilador)
char saludo[] = "Hola";

// Una versión mejorada del ejemplo anterior
// (permite un manejo de texto más simple y es
// de tamaño variable)
std::string despedida = "Hola";

// Si no se asigna un valor al definir la variable, su
// contenido quedará indeterminado (podría tomar
// cualquier valor presente en memoria al momento de
// ejecutarse el programa)

// Sin embargo, esto no es necesariamente malo. Solo hay que
// tener cuidado y asignarle un valor antes de usarla
int indet;

indet = 420; // Aquí le asignamos un valor. Nice

Una variable puede definirse como constante (const) si no se piensa modificar una vez creada:

const double phi = 1.618;

phi = 2.0; // INVÁLIDO

Sintaxis básica de un programa

Para crear un programa en C++, necesitamos crear un archivo fuente que contenga el código que queremos ejecutar. Para esto existen un sinnúmero de editores o entornos de desarrollo que pueden usar (Visual Studio, Visual Studio Code, Emacs, Vim, Atom, Sublime Text, etc.). Lo importante aquí es tener acceso a un compilador que convierta el código fuente en código máquina que el computador pueda entender. En este ejemplo voy a usar g++, parte de la suite GCC y que se encuentra disponible en toda distribución GNU/Linux (e inclusive en Windows, gracias a proyectos como MinGW, por dar un ejemplo).

La estructura de un programa C++ básico es como la siguiente:

// Bibliotecas a incluir
#include <iostream>
#include <vector>

void saludar() {
    std::cout << "Hola\n";
}

// Esta no es la forma óptima de recibir un argumento,
// pero veremos cómo mejorarlo más adelante.
int suma(std::vector<int> vec) {
    if (vec.empty())
        return 0;

    int acc = 0;
    for (const int n : vec) {
        acc += n;
    }

    return acc;
}

int main() {
    saludar();

    std::vector<int> nums{1, 2, 3, 4, 5, 6};
    std::cout << suma(nums) << "\n";

    return 0;
}

Los tres bloques entre llaves que ven se denominan funciones. Estas son trozos de código que encapsulan alguna funcionalidad y permiten separar instrucciones que cumplan propósitos diferentes. La última de estas es la más importante, pues el compilador espera que en el código que le proveamos exista como mínimo una función llamada main. Esta cumple el rol de ser el punto de entrada desde el cual el sistema operativo empezará a ejecutar código.

Una función puede recibir valores como entrada (sobre los que puede trabajar) y entregar como salida otro valor. Tanto entradas como salidas son opcionales e implementarlas o no dependerá de las circunstancias en las que estén trabajando.

En el caso de la importante función main o la función saludar, podemos notar que no aceptan argumentos, esto porque los paréntesis que vemos después del nombre están vacíos (()). En cambio, la función suma acepta un vector de enteros de nombre vec (std::vector<int> vec). Con respecto a las salidas, tanto la función main como suma devuelven un entero. En el caso de suma, la suma de los números del vector que le entregamos. En el caso de main, este número lo recibe el SO e indica si la ejecución fue exitosa (retorna 0) o no (cualquier número distinto de 0).

Ahora, para convertir este código en un ejecutable, lo guardamos en un archivo (en este caso lo podemos llamar funciones.cpp) y ejecutaremos el siguiente comando en una terminal:

g++ -o funciones funciones.cpp

Lo que hacemos aquí es invocar al compilador g++ para que lea el archivo funciones.cpp, lo procese y lo convierta en el ejecutable funciones (funciones.exe si se compila en Windows; el .exe se debería añadir implícitamente).

Este proceso es relativamente simple si solo queremos compilar un programa a partir de uno o dos archivos fuente. El problema viene cuando nuestro programa depende de varios archivos y no queremos llamar a g++ decenas de veces o escribir un comando que tome tres líneas de la pantalla. Para problemas como este existen soluciones como make o CMake, las que podemos ver más adelante. Para proyectos simples, basta con una llamada a g++ siguiendo la siguiente sintaxis:

g++ [-o <nombre_ejecutable>] <archivo_1>.cpp \
<archivo_2>.cpp ... <archivo_n>.cpp

Si no especifican un nombre para el ejecutable con -o, el compilador lo llamará a.out (nota histórica: este nombre se remonta a cuando Linux aún no existía y x86 no era la arquitectura principal para sistemas UNIX).

Bibliotecas

Además de las características propias del lenguaje (algunas de las cuales veremos después de esta sección), la librería estándar ofrece varias bibliotecas (que no son más que código ya escrito que implementa funcionalidades usadas a menudo por programadores) que nos permiten, por ejemplo, trabajar con entrada y salida de la terminal, lectura y escritura de archivos, el uso de contenedores para almacenar datos (como los vectores que ya he mencionado) y algoritmos de manipulación de datos, ordenamiento, entre muchos otros.

La biblioteca más importante para comenzar en mi opinión es <iostream>, que nos permite imprimir texto en pantalla y leerlo desde el teclado del usuario, esto por medio de los streams std::cin (la entrada estándar, usualmente el teclado), std::cout (la salida estándar, por lo general la pantalla) y std::cerr (el error estándar, que igual suele ser la pantalla, pero para mantener los errores separados de la salida normal). Se les denomina stream porque internamente podemos imaginar estos tres conductos como corrientes (streams) por las que fluye la información de manera constante, donde terminan llegando a un búfer que los va acumulando y permiten que el programa pueda captar datos que no necesariamente llegan a una tasa constante.

Más adelante veremos estructuras y objetos como std::vector, std::list o std::fstream, que nos otorgan más posiblidades para resolver problemas con nuestro código.

`<iostream>`: Entrada y salida de terminal

Si desean imprimir texto en pantalla, pueden hacer uso de std::cout, el cual recibirá cualquier texto, número o variable que le entreguen y lo imprimirá en la salida estándar o stdout:

#include <iostream> // Así se incluye una biblioteca.

int main() {
    // El operador << indica que queremos "insertar"
    // el texto "Hola\n" en el stream de salida
    std::cout << "Hola\n";

    return 0;
}

Si necesitan retornar un error, es buena práctica mantenerlo separado de stdout y dirigirlo en cambio a stderr (el error estándar) usando std::cerr

#include <iostream>

int hacer_algo(); // Este es un prototipo. Indica que existe
                  // una función pero cuyo código aún no está
                  // definido (en este caso podría estar al
                  // fondo del archivo)

                  // Tanto C como C++ esperan que una función
                  // esté definida antes de llamarla. Una
                  // forma de sortear esto es poniendo el
                  // prototipo al inicio y definir la
                  // función después

int main() {
    if (hacer_algo() == 0) {
        // Si la función retorna 0, imprimimos a stdout
        std::cout << "Éxito\n";
    } else {
        // De no ser así, indicamos el error en stderr
        std::cerr << "Chale\n";
    }

    return 0;
}

// Aquí definimos la función ya declarada anteriormente
int hacer_algo() {
    // ...
}

Como pueden ver, para imprimir en una nueva línea, podemos escapar el carácter ASCII para nueva línea (también conocido como LF) usando el ya tradicional \n. Sin embargo, otra forma de hacer esto es insertando en el stream de salida (ya sea std::cerr o std::cout) el manipulador std::endl, que además de insertar el carácter \n fuerza la descarga el búfer de salida en pantalla (el texto que uno pone en stdout o stderr puede no ser impreso inmediatamente, pues depende de la implentación del sistema).

std::cout << "Estas dos líneas" << std::endl;
std::cout << "van a estar en líneas separadas.\n";

Finalmente, si queremos leer información de parte del usuario (como un número o un texto), usaremos std::cin:

#include <iostream>
#include <string> // Para trabajar con el tipo std::string

int main() {
    std::cout << "Cuál es tu nombre?\n";

    std::string nombre;

    // En este caso, el operador >> indica
    // que queremos extraer un string desde
    // stdin (la entrada estándar) y guar-
    // darlo en una variable
    std::cin >> nombre;

    std::cout << "Hola, " << nombre << "!\n";

    return 0;
}

También es posible utilizar las funciones propias de la librería estándar de C (como printf, scanf y sus derviados). En este caso, en vez de incluir la biblioteca <stdio.h> usaremos <cstdio>, pues así se denomina el archivo de cabecera según la norma de C++. Técnicamente es posible usar <stdio.h> en archivos C++, pero esto no está contemplado en la norma y no es una característica garantizada en todos los compiladores. Todas las bibliotcas que vienen de la libería estándar de C existen en C++ usando la misma nomenclatura (eliminando el .h al final y anteponiendo una c).

Estructuras de control

Condicionales simples (`if`)

Los bloques if son el tipo de estructura más simple. El programa verifica si una condición es verdadera o falsa y, dependiendo del resultado, ejecuta código:

if (2 + 2 == 4) {
    // El programa ejecutará el código entre las llaves
    // si 2 + 2 es igual a 4

    std::cout << "El universo está funcionando bien.\n";
}

Es posible ejecutar otro bloque de código en caso de que la condición no sea cierta o inclusive comprobar más de una condición en caso de que la primera no sea verdadera:

if (2 - 2 == 0) {
    std::cout << "Nada que ver por aquí.\n";
} else {
    std::cerr << "Houston, tenemos un problema!\n";
}

int numero = 3;

if (numero < 0) {
    // Si el número es mayor a 0,
    // salta a la siguiente condición
    std::cout << "Negativo\n";
} else if (numero == 0) {
    // Ídem
    std::cout << "Cero\n";
} else {
    // Si esta condición tampoco
    // es verdadera, el programa no hará nada
    std::cout << "Positivo\n";
}

Condicionales de selección (`switch`)

Si tenemos que una variable pueda tener uno de varios valores, podemos comprobar cuál de estos es usando una secuencia de if-else if como en la sección anterior. Sin embargo, puede volver el código poco legible si se trata de operaciones sencillas. Para casos así, podemos usar la estructura switch:

char letra = 'a';

switch (letra) {
case 'y':
    // Si la letra fuera 'y', ejecutaría este código y
    // saldría del switch
    std::cout << 'Semivocal\n';

    // Si se omite la expresión break, el programa
    // irá revisando los otros casos hasta
    // encontrar otro break o salir del switch
    break;
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
    std::cout << 'Vocal\n';
    break;
default:
    // Este código se ejecuta sólo si ninguno de los
    // valores anteriores coincide
    std::cout << 'Consonante\n';
    break;
}

Bucles

`while` y `do while` (controlado por condición)

Los bucles while son los más simples en teoría. El código que envuelven es ejecutado si y sólo si la condición se mantiene verdadera. De serlo, se reejecuta. En caso contrario, se sale del bucle y se continúa con la ejecución del programa.

int n = 10;

while (n > 0) {
    // El programa imprimirá "Hola!" en pantalla
    // mientras n tenga un valor positivo
    std::cout << "Hola!\n";

    n--;
}

Es posible, si así se desea, crear un bucle infinito, el cual ejecutará el código que envuelve infinitamente hasta que el programa se interrumpa o el equipo que lo ejecuta se apague:

while (true) {
    std::cout << "El santuario de santa Teresita";
    std::cout << " aún necesita tu aporte\n";
}

Lo importante a considerar es que el chequeo de la condición se realiza antes de ejecutar el código del bucle, cosa contraria a lo que hace el bucle do while:

int n = 10;
do {
    std::cout << "farts\n";

    n--;

    // En este caso la verificación se hace al final
} while (n > 0);

`for` (controlado por conteo)

Cuando queremos ejecutar código una cierta cantidad fija de veces, podemos hacer uso de los bucles for, los cuales hacen uso de un contador que es chequeado en cada “vuelta” del ciclo e indica si debe seguirse ejecutando el bucle.

El bucle for es ligeramente más complicado que while, pues involucra la inicialización del contador, la condición que mantendrá el bucle activo y una instrucción que se ejecuta al final de cada iteración.

// Este bucle parte con el entero i igualado a 0.
// Se ejecutará siempre y cuando i sea menor que 10.
// Al final de cada vuelta, i será incrementado en 1
for (int i = 0; i < 10; ++i) {
    std::cout << i << "\n";
}

// Este bucle va a imprimir el valor de i 10 veces.

Si desean que la variable del contador sea inicializada antes, se puede omitir de la declaración:

int i = 42;

// ...

for (; i < 1000; i *= 2) {
    funcion_rara(i, true);
}

Lo mismo puede hacerse con la instrucción que se ejecuta al final de cada paso (el único elemento obligatorio es la condición del bucle):

for (int i = 100000; i > 0;) {
    // ...

    i = calcular_i();
}

Una forma especial de for es una no se inicializa un contador, ni condición ni instrucción de término de iteración, volviendo al código envuelto en un bucle infinito:

for (;;) {
    std::cout << "a\n";
}

`for` basado en rangos (controlado por colección)

Esta es una mis características favoritas del lenguaje y que fue implementada en C++11.

Como veremos más adelante, la librería estándar de C++ nos ofrece una gran cantidad de estructuras que nos permiten almacenar información de diversas formas, siendo una de ellas std::vector, la cual nos permite crear un arreglo expandible:

// Arreglo tradicional de tamaño fijo
int arr[] = {1, 2, 3, 4, 5};

// Esto no va a funcionar aunque quisiéramos
arr[5] = 6;

std::vector<int> vec{1, 2, 3, 4, 5}; // Vector expandible

vec.push_back(10); // Añadimos otro número al final del vector

¿Por qué menciono esto antes de explicar bien lo que es un vector? Porque algo que se hace muy a menudo con estructuras como esta es recorrer todos los elementos de esta y hacer alguna acción con ellos. La forma tradicional de hacer esto hasta 2011 era la siguiente:

std::vector<int> vec{1, 2, 3, 4, 5};

std::vector<int>::iterator it;
for (it = vec.begin(); it != vec.end(); ++it) {
    // ...
}

¿Engorroso, no es así? Fue por esto que en C++ se implementaron los for basados en rango, los cuales simplifican esta sintaxis y la convierten en esto:

for (int num : vec) {
    // ...
}

Como pueden ver, esta sintaxis es mucho más legible y cumple el mismo propósito. Al menos cuando se trate de recorrer una colección de cabo a rabo, esta última de escribir el for les ahorrará dolores de cabeza al necesitar menos código para cumplir el mismo objetivo, lo que hace al programa más mantenible y claro.

Please Don't Abuse Voice Messages

Tue, 26 May 2020 22:40:32 GMT

Just a quick rant for having something published on the page.

I’m not an extremely sociable person by any means, but I do chat pretty often with friends or classmates via IM platforms like WhatsApp. Whether it is for complaining about a shitty teacher, sending memes or sharing news, having a platform to communicate with people is a total must nowadays.

However, if there is something I cannot withstand is having to interrupt my Pretty Busy Workflow™ (mainly composed of YouTube binging, procrastinating and feeling anxiety at times) for having to listen to someone’s voice messages. It’s not a big deal for me if it is something occasional, but when it comes to people whose main way to send information to others is by voice messages I cannot but scream internally when I have to listen to three minute-long messages that I can’t listen at a 2x speed rate (if the folks at WhatsApp really cared about UX, they should have implemented features like this a long time ago; probably this wouldn’t be such a “problem” for me if that were the case).

I’m a person with a relatively low attention span, and that’s the reason I like things done fast. If you’re going to spend 15 minutes in saying something that could have been said in less than 3, you lost me. I know that voice is a lot more expressive than sending a string of text with one or two emojis, but please: use them wisely. At least try to plan what you’re going to record and be concise. People like me will thank you.