Skip to main content

Mi primera aplicación con Buck

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

r8vnhill/

Buck2 es una herramienta de construcción desarrollada por Meta (anteriormente Facebook) que se enfoca en la escalabilidad y el rendimiento. Es especialmente útil para grandes proyectos con múltiples lenguajes y muchas dependencias. En esta lección, veremos cómo crear una aplicación simple de Echo App que recibe un mensaje como argumento y lo muestra en la consola junto con la hora actual.

Estructura del proyecto​

Con Buck2, la estructura del proyecto es diferente a lo que estamos acostumbrados con Gradle. En lugar de archivos como build.gradle.kts, utilizamos archivos BUCK y un archivo principal llamado BUCK2 para definir las dependencias y las reglas de construcción.

Archivo BUCK​

El archivo BUCK define cómo compilar y vincular el código fuente. Aquí es donde describimos las reglas para la construcción de la aplicación, incluyendo el lenguaje, los archivos de código fuente y las dependencias. Para nuestra Echo App, el archivo BUCK tendría el siguiente aspecto:

BUCK
cxx_binary(
    name = "EchoApp",
    srcs = ["app/src/main/cpp/EchoApp.cpp"],
)
¿Qué acabamos de hacer?
  • cxx_binary: Esta regla le indica a Buck que queremos compilar un binario en C++.
  • srcs: Especifica el archivo fuente EchoApp.cpp.
  • deps: Aquí definimos las dependencias, en este caso un módulo para manejar la fecha y hora.

Código de la aplicación en C++​

En C++, usaremos la librería estándar para obtener la hora actual y el argumento que recibe la aplicación. El código en EchoApp.cpp se vería de la siguiente manera:

EchoApp.cpp
#include <iostream>
#include <chrono>
#include <ctime>

void echo(const std::string& message) {
    auto now = std::chrono::system_clock::now();
    std::time_t currentTime = std::chrono::system_clock::to_time_t(now);
    std::cout << std::ctime(&currentTime) << message << std::endl;
}

int main(int argc, char* argv[]) {
    for (int i = 1; i < argc; ++i) {
        echo(argv[i]);
    }
    return 0;
}
¿Qué acabamos de hacer?
  • std::chrono: Se utiliza para obtener la hora actual del sistema.
  • std::ctime: Convierte el tiempo en un formato legible.
  • echo(): Función que imprime el mensaje junto con la hora actual.
  • main(): Itera sobre los argumentos pasados al programa y llama a echo() con cada uno de ellos.

Ejecutando la aplicación​

Para ejecutar la aplicación en Buck2, usamos el siguiente comando:

buck2 run :EchoApp -- "Hello," "world!"

El resultado será similar al siguiente:

Thu Oct 17 21:12:50 2024
Hello,
Thu Oct 17 21:12:50 2024
world!

Comparación final entre Buck2​

CaracterísticaBuck2Gradle
Manejo de dependenciasManual y explícito, con control total sobre cómo se definen y vinculanAutomático, manejado a través de repositorios como Maven Central
MultilenguajeSoporta múltiples lenguajes como C++, Python, JavaPrincipalmente orientado a lenguajes de la JVM, como Kotlin y Java
EscalabilidadDiseñado para proyectos grandes y complejos con muchas dependenciasAdecuado para proyectos pequeños y medianos, pero puede escalar a grandes
Compilación incrementalMuy eficiente en compilaciones incrementales y paralelasTambién ofrece compilación incremental, pero menos eficiente a gran escala
EcosistemaFuerte en aplicaciones de servidor y compilación de binariosExcelente integración con el ecosistema Android y aplicaciones móviles
Gestión de scripts de construcciónArchivos BUCK para definir reglas de construcciónArchivos build.gradle.kts, fáciles de mantener y con soporte de Kotlin
Compilación modularControl más detallado sobre módulos y compilaciónOfrece buena modularización, pero más automatizada

Beneficios y limitaciones​

Beneficios

  • Escalabilidad: Buck2 está diseñado para grandes proyectos con muchas dependencias y múltiples lenguajes. Su enfoque en la eficiencia lo hace ideal para proyectos que necesitan compilarse de manera incremental y paralela, reduciendo el tiempo de compilación en proyectos grandes y complejos.
  • Soporte para múltiples lenguajes: Buck2 puede manejar proyectos que combinan varios lenguajes de programación, como C++, Python, y Java, ofreciendo un control detallado sobre cómo se compilan y vinculan estos lenguajes en un solo proyecto.
  • Compilación modular: Buck2 permite un control granular sobre cómo se compilan y gestionan los módulos, lo que ofrece flexibilidad para proyectos que requieren diferentes reglas de compilación para distintos componentes.
  • Control sobre reglas de construcción: Quienes desarrollan tienen un control detallado sobre cómo se definen las reglas de compilación y qué dependencias se incluyen, lo que puede ser una ventaja para proyectos con requisitos específicos y personalizados.

Limitaciones

  • Curva de aprendizaje pronunciada: Buck2 requiere una comprensión profunda de cómo definir y gestionar reglas de compilación y dependencias de manera manual. Esto puede hacer que sea más difícil de aprender y utilizar, especialmente para equipos que no están familiarizados con sus conceptos.
  • Mayor complejidad en la configuración: A diferencia de Gradle, que maneja las dependencias de manera automática, Buck2 requiere una configuración más manual y detallada, lo que puede agregar complejidad al desarrollo, especialmente en proyectos más pequeños o con menos recursos.
  • Menor ecosistema de herramientas: Mientras que Gradle tiene un ecosistema más maduro y bien integrado con herramientas populares, Buck2 se centra más en proyectos de servidores y aplicaciones de gran escala, lo que lo limita en entornos más especializados.

¿Qué aprendimos?​

En esta lección, exploramos cómo crear una aplicación simple utilizando Buck2 y C++, y comparamos este enfoque con Gradle en el contexto de Kotlin. Buck2, con su capacidad para manejar grandes proyectos multilenguaje y su control detallado sobre las dependencias y las reglas de construcción, es ideal para aplicaciones de servidor o proyectos con necesidades avanzadas de compilación y escalabilidad.

Puntos clave​

  • Manejo de dependencias: Buck2 permite un control más explícito y manual de las dependencias, a diferencia de Gradle, que automatiza este proceso a través de repositorios como Maven Central.
  • Multilenguaje y escalabilidad: Buck2 es especialmente útil en proyectos que combinan varios lenguajes, como C++, Python, y Java, y está optimizado para grandes proyectos con compilación incremental.
  • Compilación modular: Proyectos complejos se benefician del control granular que ofrece Buck2 sobre la compilación y el manejo de dependencias.
  • Curva de aprendizaje: Aunque potente, Buck2 requiere un mayor esfuerzo de configuración y una comprensión profunda de su funcionamiento, lo que puede ser una barrera para proyectos más pequeños o equipos menos experimentados.

Consideraciones para elegir entre Buck2 y Gradle​

  • Usa Buck2 si trabajas en proyectos grandes y multilenguaje que requieren compilaciones rápidas y eficientes, o si necesitas control detallado sobre las reglas de compilación.
  • Usa Gradle si tu proyecto está basado en el ecosistema JVM (Kotlin, Java) y buscas una herramienta más accesible, con un manejo automatizado de dependencias y una integración sólida con Android y aplicaciones móviles.

Ahora que hemos explorado cómo usar Buck2, ¡puedes aplicar estos conocimientos para gestionar proyectos más complejos y a gran escala!

Bibliografías Recomendadas