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