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

Conociendo Akka

¿Qué es Akka?

Es una plataforma (o framework) inspirado por Erlang que busca el desarrollo simple de aplicaciones escalables y multihilo.

Permite crear servicios transaccionales, duraderos y en tiempo real que distribuyen lógica y datos de forma conjunta.

Se puede usar con Java o Scala distintivamente.

Donde la concurrencia no se basa en la memoria compartida entre varios hilos y los métodos de sincronización (como en Java) sino que está basado en el sistema Actor-Modelo para ello.

Donde un actor es un objeto con el que puedes interactuar enviándole mensajes: cada actor puede procesar mensajes y enviarle mensajes a otros actores. Además de que los actores pueden tener un estado interno pero la comunicación sólo ocurre pasando mensajes y nunca a través de estructuras compartidas.

Donde una máquina virtual JVM pueden correr millones de actores a la vez construyendo una jerarquía padre (supervisor)-hijo con los padres monitorizando el comportamietno de los hijos. Permitiendo una forma sencilla splitear nuestros actores entre varios nodos de un cluster.

Un sencillo ejemplo con Akka

Iniciaremos creando unproyecto con Maven:

$ mvn archetype:generate -DgroupId=com.codemonkey -DartifactId=akka-hello-world -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Nos ubicamos en el directorio creado:

$ cd akka-hello-world

Editamos el archivo pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.codemonkey</groupId>
    <artifactId>akka-hello-world</artifactId>
    <version>1.0</version>
    <dependencies>
        <dependency>
            <groupId>com.typesafe.akka</groupId>
            <artifactId>akka-actor-typed_2.13</artifactId>
            <version>2.6.21</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.12.1</version>
                <configuration>
                    <source>21</source>
                    <target>21</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Construimos el proyecto:

$ mvn clean install -X

Observemos la clase principal.

HelloWorld.java

package com.codemoneky;

import akka.actor.typed.ActorSystem;
import akka.actor.typed.Behavior;
import akka.actor.typed.javadsl.AbstractBehavior;
import akka.actor.typed.javadsl.ActorContext;
import akka.actor.typed.javadsl.Behaviors;
import akka.actor.typed.javadsl.Receive;

public class HelloWorld extends AbstractBehavior<String> {

    public static Behavior<String> create() {
        return Behaviors.setup(HelloWorld::new);
    }

    private HelloWorld(ActorContext<String> context) {
        super(context);
    }

    @Override
    public Receive<String> createReceive() {
        return newReceiveBuilder()
                .onMessage(String.class, this::onMessage)
                .build();
    }

    private Behavior<String> onMessage(String message) {
        System.out.println("Mensaje recibido: " + message);
        return this;
    }

    public static void main(String[] args) {
        ActorSystem<String> system = ActorSystem.create(HelloWorld.create(), "HelloWorldSystem");
        system.tell("Hola Mundo");
        // Termina el sistema después de enviar el mensaje
        system.terminate();
    }
}

Esta clase mostrará un mensaje "Hola Mundo".

Compilamos el proyecto:

$ mvn compile

Ejecutamos:

$ mvn exec:java -Dexec.mainClass="com.codemonkey.HelloWorld"

¡Hemos creado nuestra primera aplicación con Akka!

En pocas palabras, Akka sirve para construir aplicaciones concurrentes, distribuidas y escalables en Java o Scala. Basado en el modelo de actores, facilita la gestión de procesos paralelos, comunicación asíncrona y sistemas tolerantes a fallos. Es ideal para aplicaciones en tiempo real, como chats, streaming, o microservicios, ya que simplifica la concurrencia y permite manejar grandes volúmenes de datos o usuarios de forma eficiente.

Enlaces:

https://akka.io/
https://emanuelpeg.blogspot.com/2022/09/por-que-usar-akka.html
https://www.bairesdev.com/blog/introduction-to-akka-an-open-source-library/
https://scalac.io/technologies/akka/
https://unpocodejava.com/2013/02/19/que-es-akka/

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/

Un vistazo a la programación funcional

La Programación Funcional (Functional Programming)es un paradigma de programación declarativa (decir qué queremos, pero no cómo hacerlo) basado en el uso de funciones matemáticas donde:

• Estaremos trabajando principalmente con funciones (el elemento principal para construir programas), evitaremos los datos mutables, así como el hecho de compartir estados entre funciones.
• Y donde el valor generado por una función depende exclusivamente de los argumentos alimentados a la función.
• Las funciones serán tratadas como ciudadanos de primera clase y podrán ser asignadas a variables además podrán ser utilizadas como entrada y salida de otras funciones.
• Además, evitamos a toda costa los efectos secundarios que alteren el estado del programa u otros programas.
• Ejemplos de lenguajes que soportan este paradigma son Haskell, Elixir, Erlang , Scala, y Clojure.

Características principales:

1. Funciones puras: Las funciones siempre producen el mismo resultado para los mismos argumentos y no tienen efectos colaterales (no modifican variables globales ni realizan I/O directamente). 
2.  Inmutabilidad: Los datos no se pueden modificar una vez creados. En lugar de cambiar valores, se crean nuevos valores. 
3.  Funciones de orden superior: Las funciones pueden aceptar otras funciones como argumentos o devolver funciones. 
4.  Composición de funciones: Las funciones se pueden combinar para crear otras más complejas, facilitando la reutilización de código. 
5.  Evaluación perezosa: Las expresiones no se evalúan hasta que su resultado es necesario, optimizando el rendimiento en muchos casos.

Ventajas:

1. Código más predecible y fácil de razonar gracias a la ausencia de efectos colaterales. 
2. Facilidad para la concurrencia y el paralelismo, ya que no hay variables mutables que puedan causar conflictos.

Algunos conceptos clave de la Programación Funcional

1. Funciones puras: Funciones que siempre producen el mismo resultado para los mismos argumentos. 
2. Inmutabilidad: Los valores no pueden ser modificados una vez creados.
3. Currificación: Funciones que pueden ser llamadas con menos argumentos de los que requieren originalmente.
4. Composición de funciones: Encadenar funciones mediante el operador (.).
5. Pattern matching: Hacer coincidir patrones en listas, tuplas, y otros datos estructurados.
6. Guards y condicionales: Usar guards para control de flujo condicional.
7. Recursión: La forma principal de control de iteraciones.

Ejemplo 1. Crear una función pura que nos sume dos números enteros. Este ejemplo lo haremos en Haskell.

suma.hs

suma :: Int -> Int -> Int
suma x y = x + y

main :: IO()
main = print (suma 8 3)

Como se puede ver, iniciamos con la delaración de tipos (Int). Definimos la función (suma) y en la d¿función principal (main) asignamos dos valores por default (8 y 3), lo cual nos dará como resultado 11.

Si solo queremos ejecutar el programa, abrimos una terminal y tecleamos lo siguiente:

runghc suma.hs

Si queremos compilar y crear un ejecutable, entonces:

ghc -o suma.exe suma.hs

Como la definición de una Función Pura indica, el resultado será el mismo cuando los argumentos son los mismos. Si invertimos el lugar del los valores (8, 3 por 3,8) el resultado seguirá siendo el mismo.

Aprender programación funcional se ha vuelto una "moda" que ya no solo implica el ámbito académico. Puesto que ya son muchos proyectos como la I.A. o Aprendizaje Automático que cada vez más requieren desarrolladores que dominen los principios de la matemática y, por ende, la programación funcional.

Enlaces:

https://codemonkeyjunior.blogspot.com/search?q=erlang
https://codemonkeyjunior.blogspot.com/search?q=elixir
https://emanuelpeg.blogspot.com/search?q=haskell

Instalando Scala & SBT

En este post veremos cómo instalar Scala y SBT. Para ello usaremos SDKMAN!

SBT es un gestor de proyectos similar a Gradle y Maven.

Como primera instrucción tenemos:

sdk install scala

Comprobamos su instalación:

scala --version

Ahora sbt:

sdk install sbt

Verificamos la instalación:

sbt --version

Comandos básicos de SBT

• clean, para limpiar proyecto.
• reload, recargar proyecto.
• update, actualizar proyecto.
• compile, compilar proyecto y
• run, para ejecutar proyecto.

Creamos un proyecto Play Framework con SBT. Abrimos una terminal y tecleamos:

sbt new playframework/play-scala-seed.g8

Ejecutamos la aplicación web:

sbt run

Abrimos un navegador en la ruta http://localhost:9000

Listo, nuestro primer proyecto creado!!

Enlaces:

https://sdkman.io/
https://www.scala-sbt.org/
https://www.scala-lang.org/
https://codemonkeyjunior.wordpress.com/

Scala sobre SBT parte 3

 

Comandos de SBT

clean, nos permite limpiar el proyecto.

reload, recarga el proyecto.

update, actualiza el proyecto.

compile, compila el proyecto.

run, ejecuta el proyecto.

El archivo build.sbt es similar al build.gradle de un proyecto Gradle y el pom.xml de un proyecto Maven.

build.sbt

libraryDependencies += "ch.qos.logback" % "logback-classic" % "1.2.3"
libraryDependencies += "com.typesafe.scala-logging" %% "scala-logging" % "3.9.2"

Links:

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

Un lenguaje de programación llamado Concurnas

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. A primera vista es muy parecido a Groovy.

La extensión de un programa en Concurnas es *.conc  

Instalación

$ sdk install concurnas

Compilar:

$ concc programa.conc

Ejecutar:

$ conc programa

El Hello, world y otros programas usando Concurnas:

hello_world.conc

System.out.println("Hola, mundo en Concurnas!!")

clases.conc

class X{
   def hola(){
      System.out.println("Hola desde clase X")
   }
}
class Y{
   def hola(){
      System.out.println("Hola desde clase Y")
   }
}

def main(args String[]){
   new X().hola()
   new Y().hola()
}

mayor.conc

def main(args String[]){
  x int = 4
  y int = 2
  System.out.println("x: "+x)
  System.out.println("y: "+y)
  if(x > y){
    System.out.printf("%d > %d \n",x,y)
  }
}

cuenta.conc

def main(args String[]){
	cuenta()
}

def cuenta(){
    suma int = 0
    nombre String = "Polinar Sanchez Umberto"
    palabras String[] = nombre.split(" ")
    System.out.println(nombre)
    System.out.println("Cant. de palabras: "+palabras.length)
    for(cad in palabras){
    	System.out.println(cad+" : "+cad.length())
    	suma = suma + cad.length()
    }
    System.out.println("Cant. de letras: "+suma)
}

operaciones.conc

class X{
	def hacer(args String[]){
		System.err.println("Argumentos: "+args)
	}

	def getLongitud(a String?)=> a?.length()?:'ups'
}

def main(args String[]){
  System.out.println("Hola, mundo en Concurnas!!")	
  new X().hacer(args)

  System.out.println(new X().getLongitud(null))//ups
  System.out.println(new X().getLongitud("null"))//4

  System.out.println("\t***Tipos***")
  entero int 
  entero = 453
  System.out.println("Entero: "+entero)
  System.out.printf("Entero: %d\n",entero)
  cadena String
  cadena = "Este es un buen dia para comenzar."
  System.out.printf("Cadena: %s\n",cadena)
  verdadero Boolean
  verdadero = true
  if(verdadero){
  	System.out.println(new X().getLongitud("Juan Jacobo Rosseau"))
  }

  testA()
  caracter char 
  caracter ='\u1234'
  System.out.println("Caracter: "+caracter)
  class MyClase
  objClase MyClase
  objClase = new MyClase()
  
  if(objClase == null){
  	System.out.println("El objeto es nulo")
  }else{
  	System.out.println("El objeto no es nulo")
  }

  testB()
  testC()

}

def testA(){
	System.out.println("Este es un metodo")
}

def testB(){
  a int = 32
  b int = 21
  c int = 11
  mayor int = a

  System.out.printf("a:%d, b:%d, c:%d\n",a,b,c);
  
  if(mayor < b){
    mayor = b
  }
  if(mayor < c){
    mayor = c
  }
  System.out.println("El mayor es: "+mayor);

}

def testC(){
  System.out.println(mayuscula())
  System.out.println("Suma: "+suma(12,4))
  System.out.println("Decimo: "+decimo())
  System.out.println("Centesimo: "+centesimo())
  System.out.println("Milesimo: "+milesimo())
  //Esto no compilara:
  //cadena String=null
  cadena String="null"
  try{
    cadena = cadena.toUpperCase()
  }catch(npe NullPointerException){
    System.err.println("Ha ocurrido un NullPointerException!!")
  }catch(ex Exception){
    System.err.println("Ha ocurrido una excepcion: "+ex.toString())
    ex.printStackTrace()
  }

  if(verdadero()){
    System.out.println("Suma: "+suma(-32,54))
  }

  falsoFalso Boolean = falso()
  if( not falsoFalso){
    System.out.println("Hola, mundo desde Concurnas!!!")
  }
}

def mayuscula(){
  "mayuscula".toUpperCase()
}

def suma(a int, b int){
  a+b
}

def decimo(){
  1.0/10.0
}

def centesimo(){
  1.0/100.0
}

def milesimo(){
  1.0/1000.0
}

def verdadero()=> true
def falso()=> false

Como se puede observar es muy similar a Java y/o Groovy. En próximos post seguiremos hablando de este lenguaje.

 

Sitio oficial: 

https://concurnas.com