Rakudo

Rakudo es un compilador de Raku para MoarVM y la máquina virtual de Java, que implementa la especificación de Raku.

Desarrollado originalmente dentro del proyecto Parrot, el repositorio de código fuente de Rakudo se separó del proyecto en febrero de 2009 para que pudiera desarrollarse de forma independiente, aunque todavía había muchas dependencias en ese momento. Rakudo está escrito en C, Raku y el subconjunto ligero de Raku "NQP" 

Rakudo fue lanzado en febrero de 2009, con el nombre en código Viena en honor al grupo Perl mongers que había patrocinado a uno de sus desarrolladores desde abril de 2008. Las versiones posteriores han utilizado nombres en clave basados en grupos Perl mongers.

El primer lanzamiento importante de una distribución tanto de compilador como de módulos (llamado "Rakudo *" o "Rakudo Star") fue el 29 de julio de 2010.

Cuestiones para el que no sabe, raku es el nuevo pearl (esto es por las dudas) y otra cosa busque en todo internet como corre rakudo en la jvm pero no encontre nada. Así que el que quiera aportar medeja el ejemplo en los comentarios. 

Dejo link : https://rakudo.org/

Haciendo aplicaciones asíncronas con Kotlin y Ktor

Le empresa JetBrains me parece una de las mejores hoy en día en el mundo del desarrollo. Tiene productos buenos y apuesta fuerte. Por eso siempre la sigo y encontre en su paginas este framework. 

Ktor es un framework mantenido por JetBrains. Fue construido con Kotlin desde cero. Ktor fomenta un enfoque minimalista para el diseño de aplicaciones, ya que solo necesita configurar la funcionalidad que el proyecto requiere. Con las corrutinas de Kotlin, Ktor es verdaderamente asincrónico y altamente escalable. Ktor también incluye un cliente HTTP que se implementa como una biblioteca multiplataforma y se usa ampliamente en el desarrollo de aplicaciones móviles con Kotlin.

Si bien el objetivo de Ktor es proporcionar un marco de aplicación multiplataforma de extremo a extremo para aplicaciones independiente de la plataforma. Actualmente faltan algunas plataformas. El framework admite escenarios de servidor y cliente JVM, así como clientes de JavaScript, iOS y Android, y se esta trabajando para utilizarlo en otros tipos de clientes. 

Mucho bla, bla, veamos un ejemplo de código: 

package com.example

import io.ktor.application.*

import io.ktor.response.*

import io.ktor.routing.*

fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)

@Suppress("unused") // Referenced in application.conf

@kotlin.jvm.JvmOverloads

fun Application.module(testing: Boolean = false) {

    routing {

        get {

            call.respondText("Hola Mundo!")

        }

    }

}

Si vamos a un browser http://localhost:8080 y vamos a ver "Hola Mundo!"

Dejo link: https://ktor.io/

Libros Gratuitos de Java code Geeks

 

Download IT Guides!   Spring Interview Questions The majority of the things you may be asked is collected in the list below. All core modules, from basic Spring functionality such as Spring Beans, up to Spring MVC framework are...     Android UI Design Android’s user interface is based on direct manipulation, using touch inputs that loosely correspond to real-world actions, like swiping, tapping, pinching and reverse pinching to...     JPA Minibook The basic Java framework to access the database is JDBC. Unfortunately, with JDBC, a lot of hand work is needed to convert a database query result into Java classes. Other disadvantages...     Microservices for Java Developers Microservices are a software development technique – a variant of the service-oriented architecture (SOA) structural style – that arranges an application as a collection of loosely...

Primeros pasos con Clojure, parte 26

 Seguimos con Clojure... 

Una alternativa al uso de mapas es crear un "registro". Los registros están diseñados específicamente para este caso de uso y generalmente tienen un mejor rendimiento. Además, tienen un "tipo" con nombre que se puede utilizar para comportamiento polimórfico.

Los registros se definen con la lista de nombres de campo para instancias de registros. Se tratarán como claves de palabras clave en cada instancia de registro.

;; Define a record structure

(defrecord Person [first-name last-name age occupation])

;; Positional constructor - generated

(def kelly (->Person "Kelly" "Keen" 32 "Programmer"))

;; Map constructor - generated

(def kelly (map->Person

             {:first-name "Kelly"

              :last-name "Keen"

              :age 32

              :occupation "Programmer"}))

Los registros se utilizan casi exactamente igual que los mapas, con la salvedad de que no se pueden invocar como una función como los mapas.

user=> (:occupation kelly)

"Programmer"

Primeros pasos con Clojure, parte 25

Seguimos con Clojure... 

Cuando necesitemos representar mucha información de dominio con el mismo conjunto de campos conocidos de antemano, se puede utilizar un mapa con nombre de atributos como claves. Algo así : 

(def person

  {:first-name "Kelly"

   :last-name "Keen"

   :age 32

   :occupation "Programmer"})

Dado que se trata de un mapa, las formas que ya hemos analizado para buscar un valor por clave también funcionan:

user=> (get person :occupation)

"Programmer"

user=> (person :occupation)

"Programmer"

Pero realmente, la forma más común de obtener valores de campo para este uso es invocando la palabra clave. Al igual que con los mapas y conjuntos, las palabras clave también son funciones. Cuando se invoca una palabra clave, se busca a sí misma en la estructura de datos asociativa que se le pasó.

user=> (:occupation person)

"Programmer"

La invocación de palabras clave también toma un valor predeterminado opcional:

user=> (:favorite-color person "beige")

"beige"

Como se trata de un mapa, podemos usar assoc para agregar o modificar campos:

user=> (assoc person :occupation "Baker")

{:age 32, :last-name "Keen", :first-name "Kelly", :occupation "Baker"}

Y dissoc para eliminar campos:

user=> (dissoc person :age)

{:last-name "Keen", :first-name "Kelly", :occupation "Programmer"}

Es común ver entidades anidadas dentro de otras entidades:

(def company

  {:name "WidgetCo"

   :address {:street "123 Main St"

             :city "Springfield"

             :state "IL"}})

Puede usar get-in para acceder a los campos en cualquier nivel dentro de las entidades anidadas:

user=> (get-in company [:address :city])

"Springfield"

También puede utilizar assoc-in o update-in para modificar entidades anidadas:

user=> (assoc-in company [:address :street] "303 Broadway")

{:name "WidgetCo",

 :address

 {:state "IL",

  :city "Springfield",

  :street "303 Broadway"}}

Primeros pasos con Clojure, parte 24

 

 Seguimos con Clojure... 

Hay otras dos funciones que son útiles para comprobar si un mapa contiene una entrada.

user=> (contains? scores "Fred")

true

user=> (find scores "Fred")

["Fred" 1400]

La función contains? es un predicado para verificar la contención. La función find busca la entrada clave / valor en un mapa, no solo el valor.

También puede obtener solo las claves o solo los valores en un mapa:

user=> (keys scores)

("Fred" "Bob" "Angela")

user=> (vals scores)

(1400 1240 1024)

Si bien los mapas están desordenados, existe la garantía de que las funciones keys, vals y otras corran en orden de "secuencia" siempre recorrerán las entradas de una instancia de mapa en particular en el mismo orden.

La función zipmap se puede utilizar para "comprimir" juntas dos secuencias (las claves y los valores) en un mapa:

user=> (def players #{"Alice" "Bob" "Kelly"})

#'user/players

user=> (zipmap players (repeat 0))

{"Kelly" 0, "Bob" 0, "Alice" 0}

La función de merge se puede utilizar para combinar varios mapas en un solo mapa:

user=> (def new-scores {"Angela" 300 "Jeff" 900})

#'user/new-scores

user=> (merge scores new-scores)

{"Fred" 1400, "Bob" 1240, "Jeff" 900, "Angela" 300}

Si ambos mapas contienen la misma clave, gana el de la derecha. Alternativamente, puede usar merge-with para proporcionar una función para invocar cuando hay un conflicto:

user=> (def new-scores {"Fred" 550 "Angela" 900 "Sam" 1000})

#'user/new-scores

user=> (merge-with + scores new-scores)

{"Sam" 1000, "Fred" 1950, "Bob" 1240, "Angela" 1924}

En el caso de un conflicto, se llama a la función en ambos valores para obtener el nuevo valor.

De forma similar a los conjuntos ordenados, los mapas ordenados mantienen las claves ordenadas según un comparador, utilizando comparar como función de comparación predeterminada.

user=> (def sm (sorted-map

         "Bravo" 204

         "Alfa" 35

         "Sigma" 99

         "Charlie" 100))

{"Alfa" 35, "Bravo" 204, "Charlie" 100, "Sigma" 99}

user=> (keys sm)

("Alfa" "Bravo" "Charlie" "Sigma")

user=> (vals sm)

(35 204 100 99)

Primeros pasos con Clojure, parte 23

 Seguimos con Clojure... 

Hay varias formas de buscar un valor en un mapa. La más obvia es la función get:

user=> (get scores "Angela")

1024

Cuando el mapa en cuestión se trata como una tabla de búsqueda constante, es común invocar el mapa en sí, tratándolo como una función:

user=> (def directions {:north 0

                        :east 1

                        :south 2

                        :west 3})

#'user/directions

user=> (directions :north)

0

No debe invocar directamente un mapa a menos que pueda garantizar que el resultado no será nulo:

user=> (def bad-lookup-map nil)

#'user/bad-lookup-map

user=> (bad-lookup-map :foo)

Execution error (NullPointerException) at user/eval154 (REPL:1).

null

Si deseamos realizar una búsqueda pero esperamos retornar a un valor predeterminado cuando no se encuentra la clave, debemos especifique el valor predeterminado como un parámetro adicional:

user=> (get scores "Sam" 0)

0​

user=> (directions :northwest -1)

-1

El uso de un valor predeterminado también es útil para distinguir entre una clave que falta y una clave existente con un valor nulo.

Versiones en java

Con la compra de oracle a Sun microsystem la empresa dueña de la base de datos decidió dar un impulso mayor al lenguaje Java. Y ...

Libros de Java code Geek

 

Download IT Guides!   Java Reflection Tutorial We are going to explain what reflection is in general and how can be used in Java. Real uses cases about different reflection uses are listed in the next chapters.     Abstraction in Java The principle is sometimes stated as a recommendation to the programmer, but sometimes stated as requirement of the programming language, assuming it is self-understood why abstractions...     Multithreading and Concurrency Questions There is a number of things that could potentially blow up and the complexity of systems rises considerably when concurrency is introduced. However, the...     Java Annotations Tutorial We have provided an abundance of tutorials here at Java Code Geeks, like Creating Your Own Java Annotations, Java Annotations Tutorial with Custom Annotation and Java...

Rust crea una fundación y es apoyado por Microsoft, Amazon, Google

La gente de Mozilla crea una fundación para darle impulso a Rust.  Dicha fundación es apoyada por Microsoft, Amazon, Google...

Hoy, en nombre del equipo de Rust Core, me complace anunciar la Fundación Rust, una nueva organización independiente sin fines de lucro para administrar el lenguaje de programación y el ecosistema de Rust, con un enfoque único en apoyar al conjunto de mantenedores que gobiernan y desarrollan el proyecto. La Fundación Rust celebrará su primera reunión de la junta mañana, 9 de febrero, a las 4 pm CT. La junta directiva está compuesta por 5 directores de nuestras empresas miembros fundadores, AWS, Huawei, Google, Microsoft y Mozilla, así como 5 directores de liderazgo de proyectos, 2 que representan al Core Team, así como 3 áreas de proyecto: Fiabilidad, Calidad y Colaboración.

Así comienza el primer post de Rust Fundation y es esperable que esto impulse aun más el lenguaje...

Dejo link:

https://foundation.rust-lang.org/posts/2021-02-08-hello-world/

Que puedo hacer con GraalVM?

GraalVM es (en mi opinión) uno de los proyectos más interesantes de estos tiempos en el mundo java. 

Lo que pasa es que GraalVM es un proyecto paraguas y dentro tiene varios proyectos que permiten hacer diferentes cosas. Veamos que podemos hacer con este proyecto: 

1. Correr java más rápido. La JVM de GraalVM es más rápida que la jvm estandar.  

2. Low-footprint, fast-startup Java

3. Podemos escribir aplicaciones poliglotas en : JavaScript, Java, Ruby y R

4. Ejecutar las aplicaciones java de forma nativa

5. Utilizar herramientas que funcionan en todos los lenguajes

6. Código Java como biblioteca nativa

7. Polyglot en la base de datos, correr aplicaciones Java en la base de datos. 

8. Crear tu propio lenguaje. 

Como se puede ver hay varias cositas. Vamos a centrarnos en cada una en post posteriores. 

GraalVM 21.0 introduce una JVM escrita en Java

GraalVM es (en mi opinión) uno de los proyectos más interesantes de estos tiempos en el mundo java. 

La versión 21 introduce una JVM escrita en Java. Con esta versión, Java on Truffle, una JVM escrita en Java que utiliza el framework Truffle, proporciona una opción adicional para ejecutar aplicaciones Java.

Java on Truffle, con nombre en código Espresso, se puede instalar utilizando GraalVM Updater que es un administrador de paquetes que descarga e instala paquetes que no están incluidos en la distribución principal de GraalVM.

gu install espresso

Para ejecutar una aplicación Java usando Java en Truffle, la opción -truffle debe pasarse al comando java.

java -truffle -jar awesomeApp.jar

Java on Truffle es una JVM minificada que proporciona todos los componentes centrales de una JVM como el intérprete de bytes code, la interfaz nativa de Java (JNI) y el protocolo Java Debug Wire (JDWP). Implementa las API de la biblioteca Java Runtime Environment (libjvm.so) y reutiliza todos los JAR necesarios y las bibliotecas nativas de GraalVM. Y al igual que con una JVM tradicional, Java on Truffle admite la ejecución de otros lenguajes basados en JVM como Kotlin.

Dado que está implementado en Java y puede ejecutar Java, Java en Truffle es esencialmente Java autohospedado o Java en Java. Esto abre oportunidades interesantes para investigar e innovar la JVM, ya que permite a los desarrolladores de Java leer y comprender el código fuente de la JVM y mejorarlo.

Dejo link: 

https://www.graalvm.org/release-notes/21_0/

https://www.graalvm.org/reference-manual/java-on-truffle/

Primeros pasos con Clojure, parte 22

Seguimos con Clojure... 

Los mapas se usan comúnmente para dos propósitos: administrar una asociación de claves a valores y representar datos de aplicaciones de dominio. El primer caso de uso suele denominarse diccionarios o mapas hash en otros lenguajes.

Los mapas se representan como claves y valores alternados rodeados por {y}.

(def scores {"Fred"  1400

                   "Bob"   1240

                  "Angela" 1024})

Cuando Clojure imprime un mapa en el REPL, pondrá comas entre cada par clave / valor. Estos se utilizan exclusivamente para facilitar la lectura: las comas se tratan como espacios en blanco en Clojure. 

;; same as the last one!

(def scores {"Fred" 1400, "Bob" 1240, "Angela" 1024})

Se agregan nuevos valores a los mapas con la función assoc (abreviatura de "asociar"):

user=> (assoc scores "Sally" 0)

{"Angela" 1024, "Bob" 1240, "Fred" 1400, "Sally" 0}

Si la clave utilizada en assoc ya existe, el valor se reemplaza.

user=> (assoc scores "Bob" 0)

{"Angela" 1024, "Bob" 0, "Fred" 1400}

La operación complementaria para eliminar pares clave-valor es dissoc ("disociar"):

user=> (dissoc scores "Bob")

{"Angela" 1024, "Fred" 1400}

Ubuntu renovará su instalador de sistema con Flutter

Normalmente hago post de como utilizar tecnología pero no de quien o donde se usa. Y creo muy importante esta noticia porque es un ejemplo de un uso de tecnología. 

Flutter es una tecnología que permite hacer aplicaciones mobile multiplataforma utilizando el lenguaje de programación Dart. Y la empresa canonical (dueña de Ubuntu) ha elegido esta tecnología para reescribir su instalador de sistema. 

Por lo tanto en un futuro cercano vamos a tener un intalador de Ubuntu hecho en Flutter. 

Y eso, dejo link: https://discourse.ubuntu.com/t/refreshing-the-ubuntu-desktop-installer/20659

Aplanando listas en Python

Algunas veces tenemos una estructura de lista que dentro tiene listas, y se complica demasiado trbajar con estas estructuras, por lo tanto lo que podemos hacer es aplanarlas en una lista simple. Esto lo podemos hacer con itertools.chain.from_iterable del paquete itertools, veamos un ejemplo : 

a_list = [[1, 2], [3, 4], [5, 6]]

print(list(itertools.chain.from_iterable(a_list)))

# Output: [1, 2, 3, 4, 5, 6]

# o podemos hacer : 

print(list(itertools.chain(*a_list)))

# Output: [1, 2, 3, 4, 5, 6]