jueves, 2 de septiembre de 2021

Gradle: creando un proyecto C++

Gradle ha evolucionado de ser una alternativa a Maven a ser algo más. Ahora se puede crear y administrar proyectos Kotlin, Swift y hasta C++. en este post veremos:
  1. Crear una carpeta para un proyecto C++
  2. Generar un proyecto C++ con Gradle
  3. Editar archivo principal
  4. Construir y ejecutar
1. Crear carpeta del proyecto:
$ mkdir pruebasCpp && cd pruebasCpp
2. Generar proyecto C++ con Gradle:
$ gradle init


Select type of project to generate:
  1: basic
  2: application
  3: library
  4: Gradle plugin
Enter selection (default: basic) [1..4] 2
Elegimos la opción 2, porque queremos crear una aplicación.
Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] 1
Elegimos la opción 1, porque queremos usar C++.
Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1
Elegimos la opción 2, porque... solo para variar un poco.
Listemos el el contenido del directorio:
$ tree

.
├── app
 ├── build
  ├── exe
   └── main
       └── debug
           └── app
  ├── install
   └── main
       └── debug
           ├── app
           └── lib
               └── app
  ├── obj
   ├── for-test
    └── main
        └── debug
            └── app.o
   └── main
       └── debug
           └── c0rn65lkroj8p4fvz0qgmzzjr
               └── app.o
  ├── test-results
   └── test
  └── tmp
      ├── compileDebugCpp
       ├── options.txt
       └── output.txt
      ├── compileTestCpp
       ├── options.txt
       └── output.txt
      ├── linkDebug
       ├── options.txt
       └── output.txt
      └── linkTest
          ├── options.txt
          └── output.txt
 ├── build.gradle.kts
 └── src
     └── main
         ├── cpp
          └── app.cpp
         └── headers
             └── app.h
├── gradle
 └── wrapper
     ├── gradle-wrapper.jar
     └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
└── settings.gradle.kts

Observemos nuestro archivo "build" generado.
build.gradle.kts
/*
 * This file was generated by the Gradle 'init' task.
 *
 * This generated file contains a sample C++ project to get you started.
 * For more details take a look at the Building C++ applications and libraries chapter in the Gradle
 * User Manual available at https://docs.gradle.org/7.2/userguide/building_cpp_projects.html
 */

plugins {
    // Apply the cpp-application plugin to add support for building C++ executables
    `cpp-application`

    // Apply the cpp-unit-test plugin to add support for building and running C++ test executables
    `cpp-unit-test`
}

// Set the target operating system and architecture for this application
application {
    targetMachines.add(machines.linux.x86_64)
}
3. Vamos a la carpeta donde esta el archivo principal y lo editamos:
app.cpp
/*
 * This C++ source file was generated by the Gradle 'init' task.
 */

#include <iostream>
#include <stdlib.h>
#include "app.h"

std::string demo::Greeter::greeting() {
    return std::string("Hola mundo desde Codemonkey Junior!!");
}

int main () {
    demo::Greeter greeter;
    std::cout << greeter.greeting() << std::endl;
    return 0;
}
4. Contruimos y ejecutamos:
$ ./gradlew build

$ ./app/build/exe/main/debug/app

Hola mundo desde Codemonkey Junior!!
En próximos post veremos más ejemplos.

Enlaces:
https://gradle.org/

domingo, 15 de agosto de 2021

¿Vale la pena aprender C y o C++?


En lenguaje C tuvo su época de gloria en en los años 70's. Con el advenimiento de lenguajes de programación como Visual Basic, Java, PHP y otros más es bueno recordarlo. C es un lenguaje que aún vale la pena darle un vistazo.

En este post usaremos el compilador GCC:
$ gcc --version
gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

holamundo.c
#include<stdio.h>
#define FIN 0

int main(int argc, char *argv[]){
  puts("Hola, mundo en C");
  return FIN;
}
Compilar:
$ gcc holamundo.c -o ejecutable
Ejecutar:
$ ./ejecutable

La evolución directa del lenguaje no fue ni Java o C#, fue C++. Si con C la curva de aprendizaje era alta, con C++ aumento de manera considerable. Podíamos hacer exactamente los mismo pero ahora tenia otras cosas más por aplicar como lo es: la programación orientada a objetos. Objetos, clases, herencia, polimorfismo era conceptos difíciles de aprender a quienes solo conocían los paradigmas funcional o estruturado. La primera diferencia es: la extensión de un programa en C++. Ya que se añade dos "pp" a la extensión clásica, quedando ".cpp" en vez de solo ".c". Otra diferencia es que introduce el concepto de manejo de excepciones, plantillas y ,como se mencionó antes, la programación orientada a objetos.
holamundo.cpp
#include<iostream>
using namespace std;

int main(int argc, char *argv[]){
  cout << "Hola, mundo en C++"<<endl;
  return 0;
}
En este caso usaremos el compilador G++:
$ g++ --version
g++ (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
Compilamos:
$ g++ holamundo.cpp -o ejecutable
Ejecutamos:
$ ./ejecutable

Con C comprenderemos algunos conceptos como:

  • Punteros
  • Asignación dinámica de memoria
  • Tipos definidos y estructuras
Punteros y asignación dinámica de memoria
// Puntero, variable que almacena la memoria de otra variable
int entero = 33;
int *puntero_entero = NULL;

// Asignación dinámica de memoria
puntero_entero = (int *)malloc(1*sizeof(int));

*puntero_entero = &entero;
printf("entero:%d\n",entero);
printf("puntero:%p\n",puntero_entero);
Estructuras y tipos definidos
// Creamos un tipo definido
typedef struct Nodo Nodo;

// Creamos una estructura
struct Nodo{
  long item;
  int valor;
  Nodo *izq;
  Nodo *der;
};

Nodo *raiz = NULL;
// asignamos memoria
raiz = (Nodo *)malloc(sizeof(Nodo));

raiz->item=(long)(12000);
raiz->valor=123;
raiz->izq = raiz->der = NULL;
printf("%10ld : %10d\n", raiz->item, raiz->valor);

// ... 

Con C++ conoceremos:

  • Clases y objetos
  • Manejo de excepciones
  • Plantilas
Clases y objetos
#include<iostream>
using namespace std;

class X{
   public:
    X();
    virtual ~X();
};

X::X(){
  cout << "Objeto X creado"<<endl;
}

X::~X(){
  cout << "Objeto X destruido"<<endl;
}

int main(){
  X myObj;
  return 0;
}

Un pequeño consejo:

Para quienes quieran aprender a programar sería bueno que le dieran un vistazo al lenguaje C (en lugar de Python o cualquier otro "más sencillo").

Muchos juran y perjuran que Python es el mejor lenguaje de programación para principiantes, pero creo que no es así. Existen aspectos de la programación que en el lenguaje C te enseñará para después pasar a otros lenguajes. Si sabes lo que es un puntero y para qué se usa, si sabes lo que es la asignación dinámica de memoria y para qué se usa y si sabes para qué y cómo usar las estructuras de datos entonces ya estarás listo para pasar a Java, Python o cualquier otro lenguaje compilado o interpretado. 

Entendemos que es más fácil y entendible escribir un hola mundo de esta forma:

print("Hola, mundo en Python")

que en la forma de arriba. Pero cuando enfrentes proyectos hechos en lenguajes como Java, C++ y/o C# será más difícil entender la lógica y la complejidad del código.

Enlaces:
http://conclase.net/c

domingo, 18 de julio de 2021

Elixir: Creando un proyecto con Mix

En este post veremos cómo crear un proyecto Elixir usando Mix. Pero, ¿qué es Mix? Mix es una herramienta similar a Maven o Gradle (para quienes usan Java) que nos permite crear, cmpilar, ejecutar y administrar las aplicaciones Elixir.

Tan simple como abrir una terminal y teclear:
$ mix new proyecto
$ cd proyecto
$ mix help 

Esto nos creará un proyecto con el nombre 'proyecto'. Nos ubicamos en la carpeta principal y obtenemos la ayuda.

Alejecutar el comando nos mostrará una lista de los archivos creados:

* creating README.md
* creating .gitignore
* creating .formatter.exs
* creating mix.exs
* creating lib
* creating lib/proyecto.ex
* creating test
* creating test/test_helper.exs
* creating test/example_test.exs

El archivo principal es 'proyecto.ex':
$ ls
$ cat lib/proyecto.ex

Modificamos el archivo principal y creamos un método llamado 'hola' con el clásico programa "Hola, mundo"

proyecto.ex
defmodule Proyecto do
  def hola do 
    "Hola, mundo desde proyecto Elixir"
  end
end

Nota:Es importante saber que los archivos Elixir con la extensión *.exs son interpretados y los archivos con la extensión *.ex son compilados.

Para ejecutar debemos teclear (debemos estar en la misma carpeta del proyecto):
$ iex -S mix
> Proyecto
> Proyecto.hola()
"Hola, mundo desde proyecto Elixir"
Si se edita el archivo se deberá recompilar, para eso usamos 'recompile' y volverá a acompilar el archivo:
$ iex -S mix
> Proyecto
> Proyecto.nuevo_metodo()
"AQUI SALDRIA UN ERROR"
> recompile
> Proyecto.nuevo_metodo()
"Soy un nuevo método"
En próximos post veremos más ejemplos.
Links:
https://elixirschool.com

viernes, 9 de julio de 2021

Erlang: registros (record)


Un registro es un conjunto de campos que contienen los datos que pertenecen a una misma entidad. En base de datos representa una fila, una tupla. En Erlang podemos crear un registro de la siguiente manera:

%% Define un registro 'persona'
-define(persona,{nombre, edad, edo_civil = soltero}).

%% Define un registro 'producto'
-define(producto,{nombre, precio, marca, disponibilidad=true}).

En este ejemplo hemos creado dos registros:

  1. persona
  2. producto

Un registro en Erlang es similar a una estructura en C. Suele utilizarse para almacenar un número fijo de elementos. 

typedef struct{
  char nombre[30];
  char marca[30];
  double precio;
}Producto;

Las expresiones de registro se traducen a expresiones de tupla durante la compilación.

Ejemplo. Crear un registro 'producto' con cuatro atributos: nombre, marca, precio, disponibilidad

modelo.erl
%% @doc Registros en Erlang
-module(modelo).
-author("Code Monkey Jr").
-compile(export_all).
-compile(nowarn_export_all).
-record(producto, {nombre, marca, precio, disponibilidad=true}).


inicio()->
    MyProd = #producto{nombre="Jamon de Viena", marca="El chuletón", precio=86.99},
    io:format("Producto disponible? : ~p~n",[MyProd#producto.disponibilidad]),
    io:format("Nombre: ~p~n",[MyProd#producto.nombre]),
    io:format("Marca: ~p~n",[MyProd#producto.marca]),
    io:format("Precio: ~p~n",[MyProd#producto.precio]).

%% erl
%% c(modelo).
%% modelo:inicio().
En lenguajes más "modernos" como Groovy tendríamos el siguiente resultado:
class Producto{
   String nombre
   String marca
   double precio
   boolean disponibilidad
}
Links:
https://erlangbyexample.org/records

miércoles, 7 de julio de 2021

Elixir: listas y mapas


Las listas son una secuencia ordenada de elementos del mismo tipo. Estos tipos pueden ser numéricos, strings, objetos, etc.

# Lista vacía
lista = []

# Lista llena de números
lista = [1,2,3,4,5]

Las listas son colecciones de datos enlazados. Una lista puede estar vacía, o contener una cabeza head y una cola tail. Es decir que una lista no vacía, estará compuesta por el primer elemento de la lista (head) y el resto de elementos de la lista (tail). 

[head|tail] = [1,2,3,4,5,6]
IO.puts "Head: #{head}"
IO.puts "Tail: #{tail}"

Tuplas

Las tuplas son colecciones valores que pueden ser de distinto tipo. Normalmente tienen entre dos y cuatro valores, ya que hay otros tipos de colecciones mejor preparadas para trabajar con más datos. Las tuplas se definen entre llaves {} .

tupla = {1,:ok,:hello,true, 65,[1,2,3],false,"ABC"}

Listas clave-valor

Básicamente una variante de la lista, solo que con llave-valor.

# listas clave-valor
lista_llave_valor = [nombre: "John Erlang", blog: "alquimista", url: "alquimistadecodigo.com"]

¿Qué pasa con los Mapas?

Los mapas son también colecciones de elementos clave-valor, pero se definen de forma diferente.

# Mapa en Elixir
mapa = %{:ok => 1, :hello => 2, :a => 3}
IO.puts mapa.ok # 1
IO.puts mapa.a # 3

Links:
http://agrega.juntadeandalucia.es/repositorio/02122016/a5/es-an_2016120212_9131705/33_listas.html
https://charlascylon.com/2016-03-21-tipos-colecciones-Elixir

sábado, 3 de julio de 2021

Elixir: sitios para aprender


En posts pasados hemos estado hablando del lenguaje Elixir y su relación con Erlang, pues ambos lenguajes corren sobre la máquina virtual BEAM. Elixir podría ser una extraña combinación entre Erlang y Ruby, pero con lo mejor de ambas partes. En esta ocasión veremos una lista de sitios sobre Elixir que me parecen importantes.


The Inquisitive Developer

Un sitio creado por Kevin Peter, un desarrollador web que ha tenido el interés por mostrar su paso en este lenguaje. El contenido de su sitio es muy interesante. Imperdible para quienes quieren aprender Elixir.

https://inquisitivedeveloper.com/

Sitio oficial de Elixir

El sitio oficial del lenguaje Elixir. Donde podrás descargar el lenguaje y ver los pasos de instalación, guías, documentación y ejemplos.

https://elixir-lang.org/

Sitio oficial de Joy of Elixir

El sitio oficial del libro Joy of Elixir. Donde podrás acceder al contenido del libro de manera online. Además de la opción de poder adquirir el libro.

https://joyofelixir.com/

Sitio oficial de Phoenix Framework

El sitio oficial de Phoenix Framework. Si quieres usar Elixir para tus desarrollos web este sitio es el ideal para comenzar.

https://www.phoenixframework.org/

Alias Crespo Blogspot

Blog creado por Emmanuel Goette, Alias Crespo. Un blog sobre muchas cosas, muchas. Donde podrás encontrar muchos recursos, ejemplos, etc. sobre Elixir, Erlang, etc. Imperdible para todos los desarrolladores.

https://emanuelpeg.blogspot.com/

Elixir School

Sitio para aprender sobre el lenguaje Elixir. Ideal para principiantes.

https://elixirschool.com/es/

Elixir School

Sitio para aprender sobre el lenguaje Elixir. Ideal para principiantes.

https://elixirschool.com/es/

domingo, 27 de junio de 2021

Erlang: constantes


Una variable es, básicamente, algo que puede cambiar de valor. Incluso de tipo en lenguajes de programación de tipado dinámico. Por el contrario, una constante es algo que no puede variar. Algo que permanece sin cambio, inmutable.

Para definir constantes en Erlang debemos crear una macro.

%% Macro
-define(MYMACRO (X,Y), X+Y).

%% Valor constante
-define(CONSTANTE, 3300).

Como se puede ver es muy parecido a lo que se hace en lenguajes como C.
// Macro
#define MYMACRO (X,Y) (X+Y)

// Valor constante
#define CONSTANTE 3300

Todo claro hasta aquí...pero, ¿cómo usamos estas constantes (Macros)?

%% ...
%% ...
io:format("Suma = ~p~n",[?MYMACRO(34.5,32.1)]),
io:format("Constante: ~p~n",[?CONSTANTE]).
Esto muestra como podemos hacer uso de estas constantes (Macros) en Erlang. Crearemos un programa llamado constantes.erl el cual tendrá dos constantes y una macro.
constantes.erl
%% @doc Constantes en Erlang
-module(constantes).
-author("Codemonkey Junior").
-version("1.0.0").
-export([start/0]).
-define(TITULO,"====== CONSTANTES EN ERLANG ======").
-define(MAX, 1000).
-define(SUMA (X,Y), X+Y).

start()->
   io:format("~p~n",[?TITULO]),
   io:format("MAX = ~p~n",[?MAX]),
   X = 8.7,
   Y = 4.32,
   io:format("X = ~p, Y = ~p ~n",[X,Y]),
   io:format("SUMA = ~p~n",[?SUMA(X,Y)]).


%% erl
%% > c(constantes).
%% constantes:start().
Ejecutando...
$ erl
Erlang/OTP 24 [erts-12.0.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1] [jit]

Eshell V12.0.2  (abort with ^G)
1> c(constantes).
{ok,constantes}
2> constantes:start().
"====== CONSTANTES EN ERLANG ======"
MAX = 1000
X = 8.7, Y = 4.32 
SUMA = 13.02
ok
3> 

Enlaces:
https://erlang.org/doc/reference_manual/macros.html