Conociendo Apache Tapestry

Según el sitio oficial, Tapestry es: un framework orientado a componentes para la creación de aplicaciones web altamente escalables en Java.

Como buen framework promete:

• Ser altamente productivo. 
• Implementar eficientemente el manejo de errores. 
• Inyección de dependencia. 
• Configuración vía anotaciones. 
• Alta escalabilidad. 
• Compatibilidad con Selenium. 
• Con una arquitectura abierta y extensible. 
• Java puro, sin reflexión. 
• Puedes usar Java, Groovy o Scala como lenguaje de programación base.

Se puede descargar desde us sitio oficial: https://tapestry.apache.org/download.html

También se puede crear un proyecto usando Maven. La dependencia es la siguiente:

<dependency>
  <groupId>org.apache.tapestry</groupId>
  <artifactId>tapestry-core</artifactId>
  <version>5.8.7</version>
</dependency>

Creando un proyecto con Tapestry

Requisitos:

1. Tener Maven instalado. 
2. Tener Java 21 o más instalado.

Abrimos una terminal y tecleamos:

$ mvn archetype:generate -Dfilter=org.apache.tapestry:quickstart

Donde:

groupId= com.inforhomex
artifactId= tapestry-demo
version= 1.0-SNAPSHOT
package= com.inforhomex.demo
packageInPathFormat= com/inforhomex/demo
package= com.inforhomex.demo
groupId= com.inforhomex
artifactId= tapestry-demo
version= 1.0-SNAPSHOT

Nos ubicamos en el proyecto creado:

$ cd tapestry-demo

Ejecutamos la aplicación con Jetty:

$ mvn jetty:run

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

Con esto hemos creado nuestra primera aplicación con Tapestry.

También podemos optar por clonar el proyecto base y probar las aplicaciones que vienen:

$ git clone https://github.com/apache/tapestry-5.git
$ cd tapestry-5

Nota: es necesario contar con Gradle instalado.

En conclusión: Tapestry es un framework Java para desarrollo web que se enfoca en componentes reutilizables y una arquitectura elegante. Sin embargo existen otros framework que a mi criterio llevan la delantera como Spring Framework con su Spring Boot, Quarkus, Micronaut y hasta Helidon.

Enlaces:

https://tapestry.apache.org/
https://github.com/apache/tapestry-5

Lenguajes dependientes de la Java Virtual Machine (JVM)

Un lenguaje de programación dependiente de la JVM es aquel que permite:

• Ejecución en la JVM. 
• Independencia de la plataforma. 
• Gestión automática de memoria. 
• Soporte para múltiples paradigmas. 
• Interoperabilidad. 
• Amplia biblioteca estándar. 
• Compilación a bytecode. 
• Soporte para concurrencia.

Es decir, un programa escrito en un lenguaje de programación dependiente de la JVM podrá ser:

1. Ejecutado en cualquier sistema operativo que cuente con una JVM, sin la necesidad de ser modificado. 
2. Su memoria se autogestionará gracias a un recolector de basura. 
3. Se ejecutará en un entorno seguro, gracias a su modelo de seguridad. 
4. Podrá implementar múltiples paradigmas de programación (estructurada, funcional orientada a objetos, etc.). 
5. Puede emplear librerías creadas en otros lenguajes dependientes, lo que se se conoce como interoperabilidad. 
6. El bytecode generado por la compilación es un código optimizado (optimización JIT), lo que mejora su ejecución y rendimiento. 
7. Permitir el uso de hilos. 
8. Etc.

He aquí una lista de los lenguajes de programación dependientes de la JVM más conocidos, sin tomar en cuenta a Java.

Ballerina

Es un lenguaje de programación de código abierto diseñado por WSO2, enfocado en aplicaciones nativas de la nube y la integración de servicios distribuidos.

https://ballerina.io/

Ceylon

Fue un lenguaje de programación de propósito general con una sintaxis similar a la de Java y C#. Imperativo, estático, estructurado en bloques, orientado a objetos y de orden superior.

https://projects.eclipse.org/projects/technology.ceylon

Actualmente se encuentra congelado. Una lástima, se esperaba mucho de este lenguaje. Al punto de que se creyó, realmente, como el verdadero sucesor de Java.

Concurnas

Es un lenguaje de programación JVM de código abierto diseñado para construir sistemas concurrentes, distribuidos y paralelos confiables, escalables y de alto rendimiento.

https://concurnas.com/

Clojure

Es un lenguaje de programación robusto, práctico y rápido con un conjunto de características útiles que juntas forman una herramienta simple, coherente y poderosa. Se basa en Lisp.

https://clojure.org/

Gosu

Un lenguaje JVM simple, muy simple.

https://gosu-lang.github.io/

Groovy

Es un lenguaje multifacético para la JVM. Su objetivo es proporcionar una experiencia y sintaxis similares a las de Java, pero con funciones de productividad adicionales.

https://groovy-lang.org/

Haxe

Es un lenguaje de programación estrictamente tipado, de alto nivel y código abierto con un compilador cruzado de rápida optimización.

https://haxe.org/

Jabaco

Es un lenguaje de programación dependiente de la JVM que usa como base a Visual Basic.

https://www.jabaco.org/

JRuby

Es una implementación de Ruby en Java.

https://www.jruby.org/

Jython

Se considera como una implementación de Python en Java.

https://www.jython.org/

Kotlin

Es un lenguaje de programación orientado a objetos multiplataforma, estáticamente tipado, de alto nivel y propósito general con inferencia de tipos. Actualmente muy usado para REST APIs y desarrollo de aplicaciones para móviles.

https://kotlinlang.org/

Scala

Es un lenguaje de programación multi-paradigma diseñado para expresar patrones comunes de programación en forma concisa, elegante y con tipos seguros.

https://www.scala-lang.org/

Existen más lenguajes, sin embargo la lista anterior solo incluye los más conocidos.

Enlaces:

https://web.mit.edu/ceylon_v1.3.3/ceylon-1.3.3/doc/en/spec/html_single/
https://codemonkeyjunior.blogspot.com/2024/12/concurnas-un-lenguaje-de-programacion.html
https://alquimistadecodigo.blogspot.com/2024/11/lenguajes-jvm-clojure-groovy.html

Un programa en varios lenguajes de programación (2da parte)

En una entrega anterior vimos como resolver un ejercicio de programación (determina si una cadena de caracteres tiene una longitud distinta de 0) usando diversos lenguajes de programación.

Para probar estos ejemplos puedes ir a este sitio:

https://codapi.org/

En está ocasión resolveremos el siguiente problema:

Si enumeramos todos los números naturales menores de 10 que sean múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Halla la suma de todos los múltiplos de 3 o 5 menores de 1000.

Un ejercicio propuesto en la página de Project Euler: https://projecteuler.net/

En Dlang:

multipos3o5.d

void main()
{
    import std.stdio : writefln;
    const MAX = 1000;
    int counter = 1;
    int suma = 0;
    while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           writefln("Suma = %d, Counter: %d",suma,counter);
        }
        ++counter;
    }
    writefln("Suma final= %d",suma);
}

En C:

multiplos3o5.c

#include <stdio.h>
const int MAX = 1000;

int main() {
    int counter = 1;
	int suma = 0;
    
	 while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           printf("Suma = %d, Counter: %d\n",suma,counter);
        }
        ++counter;
    }
	printf("Suma final = %d\n",suma);
    return 0;
}

En Python:

multiplos3o5.py

MAX = 1000;
counter = 1
suma = 0
while counter < MAX:
    if counter%3== 0 or counter%5==0:
        print(f"Suma: {suma}, Counter: {counter}")
        suma = suma + counter
    counter = counter + 1   
print(f"Suma final: {suma}")

En Java:

Multiplos3o5.java

package com.test.main;

public class Main {
    public static final int MAX = 1000;
    public static void main(String[] args) {
        int counter = 1;
        int suma = 0;
        while(counter < MAX){
            if(counter%3==0 ||counter%5==0){
                suma+=counter;
                System.out.printf("Suma: %d, Counter: %d\n",counter,suma);
            }
            ++counter;
        }
        System.out.printf("Suma final: %d\n",suma);
    }
}

En Javascript:

multiplos3o5.js

const MAX = 1000;
let counter = 1;
let suma = 0;
    
	while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           console.log(`Suma = ${suma}, Counter: ${counter}`);
        }
        ++counter;
    }
	console.log(`Suma final = ${suma}`);

En Clojure:

multiplos3o5.clj

(def MAX 1000)

(defn calcular-suma []
  (loop [counter 1 suma 0]
    (if (< counter MAX)
      (if (or (zero? (mod counter 3)) (zero? (mod counter 5)))
        (do
          (println "Suma:" suma ", Counter:" counter)
          (recur (inc counter) (+ suma counter)))
        (recur (inc counter) suma))
      (do
        (println "Suma final:" suma)
        suma))))

(calcular-suma)

Clojure es un lenguaje muy distinto a la mayoría. Como emplea la misma sintaxis de LISP, el cual es un lenguaje orientado a expresiones.

En Ada Language Programming:

multiplos3o5.adb

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Suma_Multiplos is
   MAX     : constant Integer := 1000;
   Counter : Integer := 1;
   Suma    : Integer := 0;
begin
   while Counter < MAX loop
      if (Counter mod 3 = 0) or (Counter mod 5 = 0) then
         Put_Line("Suma: " & Integer'Image(Suma) & ", Counter: " & Integer'Image(Counter));
         Suma := Suma + Counter;
      end if;
      Counter := Counter + 1;
   end loop;

   Put_Line("Suma final: " & Integer'Image(Suma));
end Suma_Multiplos;

En Rust:

multiplos3o5.rs

fn main() {
    const MAX: i32 = 1000;
    let mut counter = 1;
    let mut suma = 0;

    while counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            println!("Suma = {}, Counter: {}", suma, counter);
        }
        counter += 1;
    }

    println!("Suma final = {}", suma);
}

En Odin:

multiplos3o5.odin

package main

import "core:fmt"

MAX :: 1000;

main :: proc() {
    counter: int = 1;
    suma: int = 0;

    for counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            fmt.printf("Suma = %d, Counter: %d\n", suma, counter);
        }
        counter += 1;
    }

    fmt.printf("Suma final = %d\n", suma);
}

En Go:

multiplos3o5.go

package main

import "fmt"

func main() {
    const MAX = 1000
    counter := 1
    suma := 0

    for counter < MAX {
        if counter%3 == 0 || counter%5 == 0 {
            suma += counter
            fmt.Printf("Suma = %d, Counter = %d\n", suma, counter)
        }
        counter++
    }

    fmt.Printf("Suma final = %d\n", suma)
}

Continuaremos ampliando la lista de ejemplos.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/02/un-programa-en-varios-lenguajes.html
https://projecteuler.net/

Gradle: creando un proyecto C++ (2)

Hace tiempo vimos como crear un proyecto en C++ usando Gradle.

Creamos un directorio:

mkdir holamundo

Nos ubicamos en el directorio creado:

cd holamundo

Creamos el proyecto:

gradle init

Elegimos estas opciones:

PS C:\Users\HP\Documents\pruebasGradle\holamundo> gradle init

Select type of build to generate:
  1: Application
  2: Library
  3: Gradle plugin
  4: Basic (build structure only)
Enter selection (default: Application) [1..4] 1

Select implementation language:
  1: Java
  2: Kotlin
  3: Groovy
  4: Scala
  5: C++
  6: Swift
Enter selection (default: Java) [1..6] 5

Project name (default: holamundo):

Select build script DSL:
  1: Kotlin
  2: Groovy
Enter selection (default: Kotlin) [1..2] 2

Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] no


> Task :init
To learn more about Gradle by exploring our Samples at https://docs.gradle.org/8.8/samples/sample_building_cpp_applications.html

Nos ubicamps en la carpeta app:

cd app

Este será el contenido del archivo gradle.build:

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

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

// Set the target operating system and architecture for this application
application {
    targetMachines.add(machines.windows.x86_64)
}

Editamos el programa:

app.cpp

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

std::string holamundo::Greeter::greeting() {
    return std::string("Hola, mundo desde C++ y Gradle!");
}

int main () {
    holamundo::Greeter greeter;
    std::cout << greeter.greeting() << std::endl;
    return 0;
}

Construimos:

gradle build

Ejecutamos:

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

Salida:

Hola, mundo desde C++ y Gradle!

Editamos los archivos:

• app.h 
• app.cpp

Crearemos una nueva función que calcule el número de pulsaciones de una persona. Las variables de entrada de la función serán: edad y peso de la persona.

app.h

/*
 * This source file was generated by the Gradle 'init' task
 */

#ifndef APP_H
#define APP_H

#include <string>

namespace holamundo {
    class Greeter {
        public:
        std::string greeting();
        double pulsations(double weigth, int age);
    };
}

#endif

app.cpp

/*
 * This source file was generated by the Gradle 'init' task
 */

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

std::string holamundo::Greeter::greeting() {
    return std::string("Hola, mundo desde C++ y Gradle!");
}

double holamundo::Greeter::pulsations(double weight, int age) {
    return 210 - (0.5 * age) - (0.11 * weight);
}

int main () {
    holamundo::Greeter greeter;
    std::cout << greeter.greeting() << std::endl;
    std::cout <<"Pulsaciones: "<< greeter.pulsations(56.0,42) << std::endl;
    return 0;
}

Construimos y ejecutamos:

gradle build
./app/build/exe/main/debug/app.exe

Salida:

Hola, mundo desde C++ y Gradle!
Pulsaciones: 182.84

Como se puede observar han habido algunos cambios a la hora de crear el proyecto. Además que ya no podemos usar la GUI de Gradle.

Enlaces:

https://codemonkeyjunior.blogspot.com/2021/09/gradle-creando-un-proyecto-c.html

Katas en programación (un solo programa en distintos lenguajes)

 

En este post crearemos un mismo programa usando lenguajes como Java, Elixir, Erlang, Javscript, Perl, Python y otros más.

Ejercicio. Crear tres funciones:

• Función 1 para calcular  1.8 * numero, donde numero es la variable con el valor que introduce el usuario.
• Función 2 para calcular 1000 + (x + y), donde x & y son las variables que contendrán los valores que introducirá el usuario.
• Función 3 para calcular la suma de x+y+z

Código en Perl

 funciones.pl

#!/usr/bin/perl

use strict;
use warnings;
use constant MAX => 1000;
use constant VALOR => 1.8;

my($x,$y,$z);

$x=3;
$y=2;
$z=4;

print "Datos:\nx=",$x,", y=",$y,", z=",$z,"\n";


sub func1{
  return VALOR * $_[0];
}

sub func2{
  return MAX +($_[0]+$_[1]);
}

sub func3{
  return $_[0]+$_[1]+$_[2];
}

print "Resultado 1: ",func1($x),"\n";
print "Resultado 2: ",func2($y,$z),"\n";
print "Resultado 3: ",func3($x,$y,$z),"\n";

 

Código en Erlang

funciones.erl

-module(funciones).
-author("Codemonkey Junior").
-version("1.0.0").
-export([func1/1,func2/2,func3/3]).
-define(MAX,1000).
-define(VALOR,1.8).

func1(X)-> X*?VALOR.

func2(X,Y)-> ?MAX +(X+Y).

func3(X,Y,Z)-> X+Y+Z. 

Funcionando:

1> c(funciones).
{ok,funciones}
2> funciones:func1(3).
5.4
3> funciones:func2(3,9).
1012
4> funciones:func3(3,9,9).
21
5> 

Código en Elixir

funciones.exs

defmodule Constante do
  def mMAX, do: 1000
  def mVALOR, do: 1.8
end


x=2
y=4
z=5

IO.puts "Datos:\n x= #{x}, y= #{y}, z= #{z}"

func1 = fn (num) -> Constante.mVALOR*num end
func2 = fn (a,b) -> Constante.mMAX+(a+b) end
func3 = fn (a,b,c) -> a+b+c end

result1 = func1.(x)
result2 = func2.(z,y)
result3 = func3.(x,y,z)

IO.puts "Resultado 1: #{result1}"
IO.puts "Resultado 2: #{result2}"
IO.puts "Resultado 3: #{result3}"

 

Código en C#

Funciones.cs

using System;
        
public class Funciones
{

  public static readonly int MAX = 1000;
  public static readonly double VALOR = 1.8;


  public static double Func1(int num)
  {
    return VALOR * num;
  }

  public static int Func2(int x, int y)
  {
    return MAX +(x+y);
  }

  public static int Func3(int x, int y, int z)
  {
    return x+y+z;
  }

  public static void Main()
  {
    Console.WriteLine("Resultado 1: {0}",Func1(3));
    Console.WriteLine("Resultado 2: {0}",Func2(4,7));
  }

}

 

Código en C

funciones.c

#include<stdio.h>
#define VALOR 1.8
#define MAX 1000

int func1(int);
int func2(int,int);
int func3(int,int,int);


int func1(int num){
  return VALOR*num;
}

int func2(int x,int y){
  return MAX +(x+y);
}

int func3(int a,int b,int c){
  return a+b+c;
}

int main(int argc, char *argv[]){
  printf("Resultado 1:%d\n",func2(4,3));
  printf("Resultado 2:%d\n",func1(2));
  printf("Resultado 3:%d\n",func3(2,5,6));
  return 0;
}

Enlaces:

https://es.wikipedia.org/wiki/Kata_(programaci%C3%B3n)

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/