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/

Instalar Angular Cli

 

He aquí los pasos para configurar Node e instalar Angular Cli.

1. Abrir Chrome, dar F12 para abrir consola.

2. En la consola escribir:

btoa('ID:PASSWD');

3. Copiar la cadena resultante (sin comillas).

4. Abrir una terminal (CMD, etc.) e ingresar los siguientes comandos:

npm config set progress true
npm config set registry http://url_nexus
npm config set strict-ssl false
npm config set always-auth true
npm config set _auth CADENA_RESULTANTE

5. Teclear el siguiente comando para instalar Angular Cli.

npm install -g @angular/cli

Nota: en caso de no tener chrome usar el servicio de https://www.base64encode.net/javascript-btoa

Docker: instalando Erlang

 

Erlang es un es un lenguaje de programación concurrente (u orientado a la concurrencia) y un sistema de ejecución que incluye una máquina virtual (BEAM) y bibliotecas (OTP).

Joe Armstrong, el co-inventor de Erlang, sintetizó los principios de los procesos:4​

• Todo es un proceso.
• Los procesos están aislados fuertemente.
• La creación y destrucción de los procesos es una operación muy liviana.
• El envío de mensajes es la única forma de interactuar con los procesos.
• Los procesos tienen nombres únicos.
• Si conoce el nombre de un proceso, entonces puede enviarle un mensaje.
• Los procesos no comparten recursos.
• El manejo de errores no es local.
• Los procesos hacen lo que se suponen que hacen o fallan.

Instalamos una imagen de Erlang con Docker:

$ docker pull erlang

Listamos la imagen:

$ docker images -a

Para ejecutar el REPL de Erlang:

$ docker run -it --rm erlang

Para ejecutar un script de Erlang:

$ docker run -it --rm --name erlang-inst1 -v "$PWD":/usr/src/myapp -w /usr/src/myapp erlang escript programa.erl

Hola mundo en Erlang.
hola_mundo.erl

% Hola mundo en Erlang
-module(hola_mundo).
-export([main/1]).

main(_Args) ->
    io:format("Hola, mundo!!~n").

La salida del programa será: 

Hola, mundo!! 

Enlaces:

https://codemonkeyjunior.wordpress.com/2020/09/06/docker-instalando-imagen-de-php/

https://alquimistadecodigo.blogspot.com/2020/09/docker-instalando-ballerina.html

Docker: instalando Elixir

 

Elixir es un lenguaje dinámico y funcional diseñado para crear aplicaciones escalables y fáciles de mantener. En este post instalaremos una imagen de Elixir con ayuda de Docker. 

Podemos buscar una imagen tecleando:

$ docker search elixir

Descargamos e instalamos imagen de Elixir.

$ docker pull elixir

Creamos un programa Elixir. La extensión es *.exs.
hola_mundo.exs

IO.puts "Hola, mundo en Elixir!!"

El clásico programa de "Hola, mundo".  

Listamos imágenes.

$ docker images -a

Para entrar al REPL del lenguaje:

$ docker run -it --rm elixir

Para ejecutar script:

$ docker run -it --rm --name elixir-inst1 -v "$PWD":/usr/src/myapp -w /usr/src/myapp elixir elixir hola_mundo.exs

Links: 

https://elixir-lang.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

Scala sobre SBT parte 2

En el anterior post sobre SBT vimos una breve descripción de la herramienta y cómo instalarlo.

Para listar la versión de la herramienta debemos abrir una terminal de comandos y teclear:

$ sbt -version

Mostrará algo como esto:

sbt version in this project: 1.3.4

sbt script version: 1.3.4

Creando un proyecto con SBT.

1. Crear directorio.
2. Ubicarnos en directorio creado y crear subdirectorio.
3. Crear archivo build.sbt
4. Escribir el código.
5. Compilar y ejecutar.

$ mkdir testSbt
$ cd testSbt
$ mkdir sbt-ejemplo
$ cd sbt-ejemplo

Una vez en el directorio sbt-ejemplo, creamos el archivo build.sbt con cualquier editor de textos.

Ahora creamos el programa.

Hola.scala

package main

object Hola{

   def main(args: Array[String]):Unit{
       println("Hola, mundo desde Codemonkey Junior")
   }

}

Para compilar y ejecutar el programa tecleamos:

$ sbt

 >compile
 >run

Si no hay ningún error, mostrará el mensaje:

"Hola, mundo desde Codemonkey Junior"

Links:

https://emanuelpeg.blogspot.com/2020/05/libro-gratuito-de-scala.html

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

http://www.scala-js.org/

https://sdkman.io

Scala sobre SBT

SBT (Simple Build Tool) es una herramienta similar a Gradle, pero para el lenguaje Scala, un lenguaje de programación dependiente de la JVM.

Con esta herramienta podremos crear proyectos Scala. Crear su documentación y soportar subproyectos.

El archivo build.sbt es como el build.gradle para Gradle y/o el pom.xml para Maven.

Instalando SBT usando SDKMAN!

$ sdk install scala

Instalando SBT en Windows

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


En siguientes post veremos como usar esta herramienta.


Enlaces:
https://emanuelpeg.blogspot.com/2020/05/libro-gratuito-de-scala.html
https://www.scala-sbt.org/
http://www.scala-js.org/
https://sdkman.io
 

Groovy for todos!!

En este blog hemos tratado algunos temas sobre Groovy, un lenguaje de programación de tipado dinámico (o pseudo dinámico) muy parecido a lenguajes como Python y/o Ruby.

Muchos, es la verdad, no lo conocen y mucho menos lo usan de manera profesional. Esto nos hace preguntar ¿Por qué?  ¿Por qué casi nadie lo conoce/usa? La respuesta es más que obvia: Java sigue activo y otros lenguajes como Kotlin se comen a los lenguajes dependientes de la máquina virtual.

Además tomando en cuenta que surgen otras dudas:
¿Qué puedo hacer con Groovy que no pueda hacer con Java?
¿Me conviene ($) aprenderlo?
¿Lo usaré en algún trabajo?

La única forma de responder esto es ponernos a la obra y conocer el lenguaje. Y para ello su instalación será esencial. Nosotros usaremos SDKMAN! que nos facilita la existencia.

$ sdk install groovy

Una vez instalado crearemos el clásico programa Hola, mundo.

GroovyMain.groovy

class GroovyMain{

  static void main(args){
     println "Hola, mundo!!!"
  }

}

Compilamos y ejecutamos:

$ groovyc GroovyMain.groovy
$ groovy GroovyMain

Mostrará el mensaje "Hola, mundo!!!" en consola.

Como dice la documentación oficial: Groovy se permite algunas cosas que no se permiten en Java, comoel tipado pseudo dinámico.

def fecha = new Date() 

fecha = null 

def entero = "33" 

entero = 33 // permitido
String nombre = "Groovy is wonderful!!!"

nombre = true //Cuidado con esto 
boolean verdadero = false
def file = new File("archivo.sql");

Otra cosa que no debemos olvidar: Gradle, un gestor de proyectos similar a Maven, usa Groovy (DSL).


 Links:
http://groovy-lang.org/

Java: Unsupported major.minor version 52.0

Es común encontrar excepciones en proyectos Java. No importando si el código está "bien escrito", siempre habrá algo que nos causará un disgusto futuro.

Recordar:Una excepción es una anomalía en el flujo normal de un programa. Un error, muchas veces, es un fallo irreparable en la que el desarrollados y/o usuario no les queda otra cosa más que pedir clemencia al Creador de Universo y la solución caiga del mismo cielo.

Uno de las más famosas es el NullPointerException, pero en está ocasión lo que nos trae ahora es el Error  Unsupported major.minor version 52.0

¿Por qué ocurre este error?
Parece ser que es porque una clase fue compilada en una versión de JDK específica y se quiere ejecutar en Otra  Versión de JDK. La clase java.lang.UnsupportedClassVersionError nos lanza este error.


Ejemplo. Compilas tu programa en JDK 5 y tratas de ejecutarlo con un JDK 4.

La siguiente tabla nos puede aclarar un poco las cosas.

Tabla

//Tabla de versiones y número correspondiente
Java SE 13 = 57,
Java SE 12 = 56,
Java SE 11 = 55,
Java SE 10 = 54,
Java SE 9 = 53,
Java SE 8 = 52,
Java SE 7 = 51,
Java SE 6.0 = 50,
Java SE 5.0 = 49,
JDK 1.4 = 48,
JDK 1.3 = 47,
JDK 1.2 = 46,
JDK 1.1 = 45

La versión 52 corresponde al JDK 8. Lo que quiere decir que...

¡COMPILAMOS EL CÓDIGO EN UN JDK 8 Y TRATAMOS DE EJECUTARLO EN UN JDK MENOR!

Posibles soluciones, si es que usas Eclipse, son:

1. Project -> Properties -> Java Compiler Enable -> Compiler compliance level to 1.7, 1.6, 1.5 ...

2. Window -> Preferences -> Java ->  Compiler ->Compiler compliance level to 1.7, 1.6, 1.5 ...

3. Revisar que el JDK y el JRE sean la versión 8.

Links:
https://javarevisited.blogspot.com/2015/05/fixing-unsupported-majorminor-version.html