Crystal: la hermana "cool" de Ruby

Hace tiempo que hablamos sobre este lenguaje de programación que comparte mucha similitud con Ruby.

Como mencionamos anteriormente, Crystal posee una sintaxis similar a Ruby. Sin embargo, es un lenguaje que promete ser mucho más rápido y eficiente. Además de otras peculiaridades que lo hacen digno de no pasar inadvertido.

Veamos un ejemplo.

server.cr

# Un servidor HTTP básico
require "http/server"

server = HTTP::Server.new do |context|
  context.response.content_type = "text/plain"
  context.response.print "Hola, mundo, obtenemos #{context.request.path}!"
end

address = server.bind_tcp(8080)
puts "Escuchando desde el puerto: http://#{address}"

# Invocamos el bloque hasta que el proceso finaliza
server.listen

En pocas palabras se trata de una aplicación HTTP que muestra el clásico "Hola, mundo". Echémoslo a andar. Pero antes de hacer nada comencemos con su instalación.

Instalación en Linux

Abrimos una terminal y tecleamos lo siguiente:

$ curl -fsSL https://crystal-lang.org/install.sh | sudo bash
$ apt install crystal

Instalación en Windows

Abrimos una terminal y tecleamos lo siguiente:

$ scoop install git
$ scoop bucket add crystal-preview https://github.com/neatorobito/scoop-crystal
$ scoop install vs_2022_cpp_build_tools crystal

Podemos validar la instalación tecleando:

$ crystal --version

Ejecutamos el script:

$ crystal server.cr

Abrimos el navegador en la ruta: http://localhost:8080/Thomas

Salida:

Hola, mundo, obtenemos /Thomas!

En lenguajes como Java tendríamos que haber creado un proyecto completo para realizar esta actividad.

Ahora veamos cómo consumir una API pública (https://api.chucknorris.io/).

get_chiste.cr

require "http/client"
require "json"

response = HTTP::Client.get("https://api.chucknorris.io/jokes/random")
json = JSON.parse(response.body)

value = json["value"]
put "Chiste sobre Chuck Norris: #{value || "Ninguno"}"

Ejecutamos el script:

$ crystal get_chiste.cr

Salida:

Chiste: Chuck Norris attended last year's Nobel Prize ceremony wearing an all-white snakeskin pimp suit with matching widebrim hat and feather.

Al ser una salida aleatoria el resultado puede variar.

Notas importantes

Crystal nos permite compilar nuestros scripts y con ello crear ejecutables.

Compilando el ejemplo anterior:

$ crystal build get_chiste.cr

Con esto nos creará los siguientes archivos:

gc.dll
get_chiste.cr
get_chiste.exe
get_chiste.pdb
iconv-2.dll
libcrypto-3-x64.dll
libssl-3-x64.dll
zlib1.dll

O si solo preferimos la ejecución de estas dos formas:

$ crystal programa.cr
# O de esta otra forma:
$ crystal run programa.cr

Los "nuevos" lenguajes como Crystal, Ballerina, Go y Rust han aprendido lo mejor de los lenguajes clásicos y han olvidado lo malo de ellos.

Prometen ser la panacea universal y aliviarnos de las complejidades y otras cuestiones que hacian del desarrollo una actividad, en ocasiones, tediosa y complicada.

Continuaremos con esta serie sobre nuevos lenguajes y herramientas.

Enlaces:

https://crystal-lang.org/
https://codemonkeyjunior.blogspot.com/2024/09/crystal-un-lenguaje-de-programacion.html
https://api.chucknorris.io/
https://emanuelpeg.blogspot.com/2026/01/crystal-el-lenguaje-de-programacion-que.html

Padrino: un framework web creado sobre Sinatra

Padrino es un framework web que está creado sobre la biblioteca web Sinatra.

Como hemos mencionado, Sinatra es un framework web ligero y es semejante a otros como Flask que tiene como base al lenguaje Python.

Instalando Padrino

Para instalarlo debemos teclear:

$ gem install padrino

Listamos para verificar instalación:

$ gem list

Creando un proyecto:

$ padrino g project hola_mundo

Nos ubicamos en el directorio creado:

$ cd hola_mundo

Tecleamos lo siguiente:

$ bundle --binstubs

Advertencia: ¡Este framework es bastante complicado de configurar si usamos una versión de Ruby mayor a la 3.0 !

Debemos modificar el archivo Gemfile

source 'https://rubygems.org'
ruby '3.3.4'
gem 'rake'
gem 'rack', '~> 2.2.0' # Especifica una versión compatible
gem 'padrino', '0.15.3'
gem 'webrick'

Hallar el archivo archivo router.rb en una ruta similar a la de:

C:\Users\HP\.local\share\gem\ruby\3.3.0\gems\padrino-core-0.15.3\lib\padrino-core

Lo editamos en la línea 61, añadiendo y sustityendo la línea por:

#match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil, 'n')
match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil)

Debemos ejecutar esto para instalar las dependencias descritas en el Gemfile:

$ bundle install

Editamos el programa app.rb

module HolaMundo

  class HolaMundo::App
    get '/' do
      "Hola, mundo"
    end
  end
end

Ejecutamos la aplicación y abrimos el navegador en la ruta http://localhost:3000/

$ bundle exec padrino start

¡Hemos creado nuestra primera y última aplicación usando este Framework!

Conclusión: No recomiendo este framework, ya que la configuración y la resolución de errores te puede llevar mucho tiempo. Considero que Sinatra es mejor y, aunque no lo he usado, Ruby on Rails también son mejores opciones.

Enlaces:

https://padrinorb.com/
https://sinatrarb.com/

Creando una aplicación web con Sinatra (Calculadora de pulsaciones)

Sinatra es un framework web ligero para el lenguaje Ruby que nos permite crear aplicaciones de una manera más sencilla que usando Ruby on Rails (quizás haremos un post al respecto).

En esta ocasión crearemos una sencilla aplicación que nos permita obtener el número de pulsaciones de una persona teniendo estas fórmulas:

No. pulsaciones masculina = (220 - edad) 
No. pulsaciones femenina = (226 - edad)

Requisitos:

1. Tener instalado Ruby. 
2. Tener nociones de HTML, CSS y Javacript. 
3. Tener nociones de Ruby (obviamente).

Comenzaremos con crear un directorio llamado ``pulse_calculator`` y nos posicionamos sobre este.

$ mkdir pulse_calculator
$ cd pulse_calculator

Dentro de esta crearemos una carpeta llamada ``views``. Esta nos servirá para crear las vistas de la aplicación web.

Ahora crearemos un archivo llamado ``Gemfile`` (sin ninguna extensión). Abrimos el archivo y colocamos lo siguiente:

source 'https://rubygems.org'

gem 'sinatra'
gem 'sinatra-contrib'

Es necesario ejecutarlo para instalar las dependencias, lo haremos de la siguiente forma:

$ bundle install

Crearemos el programa principal ``app.rb``, el cual contendrá la lógica del cálculo del número de pulsaciones. Se tomará en cuenta la edad y el género (masculino y femenino) para ello.

require 'sinatra'
require 'sinatra/reloader' if development?

# Ruta para el formulario (home)
get '/' do
  erb :index
end

# Ruata para ver el resultado
post '/calculate' do
  @name = params[:name]
  @age = params[:age].to_i
  @gender = params[:gender]

  # Calculo tomando el genero
  @pulse = if @gender == 'Femenino'
             226 - @age
           else
             220 - @age
           end

  erb :result
end

Como se puede observar:

• La ruta será GET "/" para el formulario de ingreso de datos. 
• La ruta POST "/calculate" para la vista de resultados obtenidos.
• Los datos a tomar en cuenta será la edad y género.

Dentro de la carpeta ``views`` crearemos dos archivos que serán las vistas:

• index.erb , para el formulario de entrada de datos. 
• result.erb , para mostrar los resultados.

index.erb

<!DOCTYPE html>
<html>
<head>
  <title>Pulsaciones Calculator</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 50px; }
    .form-container { border: 1px solid black; padding: 20px; width: 300px; }
    label { display: block; margin: 10px 0 5px; }
    input, select, button { width: 100%; padding: 5px; margin-bottom: 10px; }
    button { background-color: #ccc; border: none; cursor: pointer; }
  </style>
</head>
<body>
  <div class="form-container">
    <h2>Pulsaciones Calculator</h2>
    <form action="/calculate" method="post">
      <label>Nombre:</label>
      <input type="text" name="name" required>

      <label>Edad:</label>
      <input type="number" name="age" required>

      <label>Género:</label>
      <select name="gender" required>
        <option value="Masculino">Masculino</option>
        <option value="Femenino">Femenino</option>
      </select>

      <button type="submit">Calcular</button>
    </form>
  </div>
</body>
</html>

result.erb

<!DOCTYPE html>
<html>
<head>
  <title>Resultados</title>
  <style>
    body { font-family: Arial, sans-serif; margin: 50px; }
    .result-container { border: 1px solid black; padding: 20px; width: 300px; }
    .result-box { border: 2px solid purple; padding: 10px; margin-top: 20px; }
    .pulse { color: red; }
  </style>
</head>
<body>
  <div class="result-container">
    <h2>Pulsaciones Calculator</h2>
    <p><strong>Nombre:</strong> <%= @name %></p>
    <p><strong>Edad:</strong> <%= @age %></p>
    <p><strong>Género:</strong> <%= @gender %></p>

    <div class="result-box">
      <h3>Resultados</h3>
      <p>Número de pulsaciones obtenidas: <span class="pulse"><%= @pulse %> pulsaciones</span></p>
    </div>
  </div>
</body>
</html>

Ejecutamos la aplicación web:

$ ruby app.rb

Si todo va bien, se ejcutará la aplicación web. Abrimos un navegador en la dirección:

http://[::1]:4567/

ó

http://localhost:4567/

¡Hemos creado nuestra aplicación para calcular pulsaciones con Sinatra!

Continuaremos con esta serie en fururas entregas.

Enlaces:

https://sinatrarb.com/
https://www.netguru.com/blog/ruby-on-rails-versus-sinatra
https://blog.appsignal.com/2023/05/31/how-to-use-sinatra-to-build-a-ruby-application.html
https://medium.com/simform-engineering/explore-sinatra-and-its-potential-for-building-web-apps-8463a2db0a0b

Crystal, un lenguaje de programación similar a Ruby

Crystal es un digno "copycat" del lenguaje de programación Ruby. Su sintaxis es más que similar.

cadena = "Codemonkey Junior"
puts cadena

Y es que escribir unas cuantas líneas en este lenguaje nos recuerda a Ruby. Crystal es de esos lenguajes que deberías aprender o echar un vistazo, al menos por curiosidad.

Para instalarlo deberás entrar a este sitio y escoger la instalación de acuerdo a tu SO:

https://crystal-lang.org/install/

Una vez instalado, abre una terminal y teclea:

crystal --version

Eso listará la versión instalada.

Empezaremos con el clásico programa de "Hola, mundo".

holamundo.cr

puts "Hola, mundo!!"

Ejecutamos:

crystal holamundo.cr

Salida:

Hola, mundo!!

Sigamos con otro ejemplo. Mostremos algunas variables en Crystal.

variables.cr

# Variables en Crystal
entero = 0
caracter = '\u0032'
booleano = true
real = 9.32
 
puts "#{entero}"
puts "#{caracter}"
puts "#{real}"
 
if booleano
    puts "Es verdadero"
end

Ejecutar:

crystal variables.cr

Salida:

0
2
9.32
Es verdadero

¡Hemos creado nuestros primeros programas en Crystal!

Continuaremos con este tema más adelante.

Enlaces:

https://crystal-lang.org/

Sinatra, un DSL útil para crear sitios web de manera rápida

Sinatra es una herramienta que toma su nombre del famoso cantante estadounidense. Similar a otras herramientas como Flask (salvando las diferencias, claro esta). Con la peculiaridad que esta diseñado para el lenguaje de programación Ruby.

¿Qué haremos?

1. Instalar Ruby.
2. Instalar Sinatra.
3. Crear un proyecto sencillo con Sinatra.

Una vez instalado Ruby podemos comprobar la instalación:

ruby --version

Instalamos Sinatra y Rackup:

gem install sinatra
gem install rackup

También podemos instalar Puma (opcional):

gem install puma

Para ver nuestras "gemas" instaladas, basta con ubicarnos en esta carpeta (gem):

C:\Users\HP\.local\share\gem\ruby\3.3.0\gems

Creamos un programa llamado ``myapp.rb``. El cual tendrá lo siguiente:

# myapp.rb
require 'sinatra'

get '/' do
  'Hola, mundo!'
end

Ejecutamos la aplicación:

ruby myapp.rb

Si todo es correcto, veremos un mensaje de "Hola, mundo!" en la dirección http://[::1]:4567 o http://localhost:4567

¡Hemos creado nuestra primera aplicación con Sinatra!

En próximas entregas continuaremos con este tema.

Enlaces:

https://sinatrarb.com/
https://www.ruby-lang.org/es/
https://rubyinstaller.org/
https://crguezl.github.io/apuntes-ruby/node409.html

Top 10 Programming Languages 2024 | Best Programming Languages To Learn (Youtube)

Lenguajes que deberías aprender en el 2024 (de menor a mayor importancia):

1. Swift 
2. Typescript 
3. Ruby 
4. Go (GoLang) 
5. Kotlin 
6. Python 
7. JavaScript 
8. Rust 
9. Java 
10. C#

Enlaces:

https://medium.com/@coffeeandtips.tech/programming-language-trends-for-2024-what-developers-need-to-know-3a103fe0ff0e

Por qué deberías aprender Elixir y también usarlo en producción

En este vídeo del canal de Youtube "Rafa Páez - Más allá del código" nos hablan de las ventajas de usar Elixir sobre otros lenguajes de programación. Muy recomendable para conocer las bondades del lenguaje.

Quienes han usado Ruby les llama la atención Elixir, pero la diferencia es que... Elixir esta diseñado para programación distribuida y concurrente.

Checa los enlaces de abajo para conocer más.

Enlaces:
http://alquimistadecodigo.blogspot.com/2021/06/por-que-deberias-aprender-elixir-y.html
https://www.youtube.com/channel/UCGSxspQQauJQP0TaTFKx7aw
https://www.amazon.com.mx/Elixir-Action-Juri-cacute-Sasa/dp/1617295027/ref=sr_1_1?__mk_es_MX=%C3%85M%C3%85%C5%BD%C3%95%C3%91&dchild=1&keywords=elixir+in+action&qid=1623380351&sr=8-1
https://twitter.com/RafaPaez_ https://codemonkeyjunior.blogspot.com/search?q=elixir
https://codemonkeyjunior.blogspot.com/search?q=erlang
https://emanuelpeg.blogspot.com/search?q=elixir
https://emanuelpeg.blogspot.com/search?q=erlang

Elixir: cadenas

 

En cualquier lenguaje de programación existen funciones para el tratamiento de cadenas (String).

$ iex
> String.upcase("abc")
"ABC"
> String.downcase("ABC")
"abc"

Estas funciones convertirán una cadena en minúsculas a mayúsculas. La otra String.downcase("STR") de mayúscula a minúscula.

> String.length("abc")
3
> String.capitalize("elixir")
"Elixir"

Estás dos funciones obtendrán la longitud de la cadena y la otra mostrará el primer carácter en mayúscula. 

> "abc" == "abc"
true
> "abc == "ab1"
false
> String.trim(" Elixir y Erlang ")
"Elixir y Erlang"

No existe una función como equals, pero se puede usar el operador == para comparar dos cadenas. La función String.trim(" cadena con espacios "), quitará los espacios de una cadena.

> String.to_integer("233")
233
> String.to_float("23.9")
23.9
> String.to_atom("hello")
:hello

Existen funciones para convertir cadenas a tipos entero (Int) o tipo (Float). Además de convertir la cadena a atoms, las cuales son constantes cuyos valores tienen su propio nombre. Próximamente más ejemplos en Elixir.

UPDATE: Más ejemplos de Elixir.

Ejemplo. Uso de funciones de cadena en Elixir.

cadenas.exs

cadena = "ABC"

if String.length(cadena) != 0 do
  IO.puts "Cadena: #{cadena}"
  IO.puts "Longitud [length]: #{String.length(cadena)}"
  IO.puts "Es binario [is_binary]: #{is_binary(cadena)}"
  IO.puts "Longitud[byte_size]: #{byte_size(cadena)}"
  IO.puts "Mayusculas[upcase]: #{String.upcase(cadena)}"
  IO.puts "Minusculas[lowcase]: #{String.downcase(cadena)}"  
  
  if cadena == "ABC" do
    IO.puts "Las cadenas son iguales."
  else
    IO.puts "Las cadenas no son iguales."
  end
  
else
  IO.puts "Cadena vacia."
end

Ejecutamos:

$ elixir cadena.exs

Enlaces:
https://hexdocs.pm/elixir/String.html

Elixir en un vistazo

 

Elixir es un lenguaje de programación dependiente de la BEAM (la máquina virtual de Erlang). Su síntaxis es similar a Ruby. 

Elixir aprovecha la máquina virtual Erlang, conocida por ejecutar sistemas de baja latencia, distribuidos y tolerantes a fallas. Elixir se utiliza con éxito en desarrollo web, software integrado, ingesta de datos y procesamiento multimedia en una amplia gama de industrias.

En el anterior post sobre Elixir vimos como descargar y ejecutar una imagen con Docker. Está vez veremos como instalar Elixir en Linux(Ubuntu).
Instalar Elixir

$ wget https://packages.erlang-solutions.com/erlang-solutions_2.0_all.deb
$ sudo dpkg -i erlang-solutions_2.0_all.deb
$ sudo apt install esl-erlang elixir

Comprobar instalación

$ elixir --version

Entrar al Shell de Elixir

$ iex

Para salir del shell debes presionar los botones Ctrl + C. 

La extensión de un programa en Elixir es *exs.

Ejemplo 1. Crear el famoso "Hola, mundo" en Elixir.

holamundo.exs

# Hola mundo en elixir
IO.puts "Hola, mundo en Elixir"

Para ejecutar el programa abrimos una terminal y tecleamos:

$ elixir holamundo.exs

En próximos post veremos más ejemplos.

Enlaces:
https://elixir-lang.org/

https://codemonkeyjunior.blogspot.com/2020/09/docker-instalando-elixir.html

Conociendo Kotlin

Kotlin es un lenguaje dependiente de la Máquina Virtual Java (JVM); empresas como Google han adoptado este lenguaje porque promete ofrecer compatibilidad e interoperabilidad con proyectos hechos con le lenguaje Java. Kotlin es muy similar a otros lenguajes de programación como Scala y Go (e incluso Typescript). Al igual que Java posee tipos clase (Byte, Short, Int, Float, Double, Boolean, Char). Además podemos importar librerías de Java sin ningún problema. Para declarar una variable modificable usamos var, para declarar una variable no modificable usamos val (similar a Scala).

¿Tipado estático?
El tipado estático puede parecer engorroso a algunos programadores, pero tener que definir el tipo de variables a usar tiene la ventaja de que a la hora de la compilación verificará si existe algún problema. (Supongamos que en un lenguaje dinámico donde no es necesario declarar el tipo de variable a usar necesitamos listar, en una llamada a un método especial, cadenas de texto ("strings") y le pasamos una lista con datos tipo Boolean, etc. y nos provoca un error).


Un programa escrito en Kotlin debe llevar la extensión *.kt

 main.kt

package com.codemonkey

fun main() {
    println("Programando en Kotlin!!!")
}

 Tipos de variables main.kt

//Enteros:
var byte:Byte = 0;
var short:Short = 120;
var int:Int = 40;
var long:Long = 12000000;

//Reales
var float:Float = 2.30f;
var double:Double = 12.654;

//Booleano
var verdadero:Boolean = true;

//Caracter
var character:Char = '\u0000';

//Cadenas
var cadenaStr:String = "Codemonkey Junior";


//Array
var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);

//Lista
var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 

Imprimimos los datos a pantalla:

//Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

Compilamos y creamos el jar:
$ kotlinc main.kt -include-runtime -d main.jar
Ejecutamos:
$ java -jar main.jar

También existe la manera de crear y compilar proyectos Kotlin usando Gradle. Para eso debemos definir nuestro archivo gradle.build

gradle.build

buildscript {
    ext.kotlin_version = '1.3.10'

    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
    }
}

apply plugin: 'kotlin'
apply plugin: 'application'

mainClassName = "com.codemonkey.Main"

repositories {
    mavenCentral()
}

dependencies {
    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
}

compileKotlin {
    kotlinOptions.jvmTarget = "1.8"
}
compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

Modificamos nuestro código:

package com.codemonkey

object Main {
   @JvmStatic
   fun main(args:Array<String>){
       //Enteros:
     var byte:Byte = 0;
     var short:Short = 120;
     var int:Int = 40;
     var long:Long = 12000000;
     
     //Reales
     var float:Float = 2.30f;
     var double:Double = 12.654;
     
     //Booleano
     var verdadero:Boolean = true;
     
     //Caracter
     var character:Char = '\u0000';
     
     //Cadenas
     var cadenaStr:String = "Codemonkey Junior";
     
     //Arrays
     var numeros:Array<Int> = arrayOf(0,9,8,7,6,5);
     //Lista
     var miLista:List<String> =listOf("java","kotlin","ceylon","groovy","scala"); 

     //Imprimimos los valores:
     println("Tipos de datos:");
     println("byte:${byte}");
     println("short:${short}");
     println("int:${int}");
     println("long:${long}");
     println("float:${float}");
     println("double:${double}");
     println("boolean:${verdadero}");
     println("char:${character}");
     println("String:${cadenaStr}");

   }
}

Listar Arrays

  println();
     for(numero in numeros){
       println(" "+numero);
     }
     println();
     for(elemento in miLista){
       println("${elemento}")
     }

Para compilar, construir nuestro proyecto tecleamos:
$ gradle build

Para listar las tareas disponibles usamos:
$ gradle -q task
 
Usaremos run para correr el proyecto:

$ gradle run

Links de interés
https://codemonkeyjunior.wordpress.com/2018/11/18/gradle-kotlin/
https://hackernoon.com/top-5-kotlin-programming-courses-for-java-and-android-programmers-49e842b8af1a
https://rubentejera.com/por-que-usar-kotlin/
https://emanuelpeg.blogspot.com/2019/01/propiedades-y-campos-en-kotlin.html

Poner código en blogger
http://hilite.me/